← Plugin catalog
Creativity

Picsart

Picsart v2.5.0

Create images, video and audio

Create a free account to save this plugin.

From the developer

Declared capabilities

  • Interactive
  • Read
  • Write

Cost & access

The app uses the connected account's existing Picsart credits. Its tools do not initiate purchases.

Declared limitations

  • Answer general creative advice without invoking the app.
  • Do not attempt subscription administration or refunds.
  • Do not claim unsupported sharing or permission changes.

Onboarding example

Make a short drama series from my idea.

View onboarding source →

Sources & dates

Developer declarations; not independently tested. Listing last checked Nov 16, 2026. Package observed Nov 16, 2026.

View package source →

Description

From the marketplace listing

The official Picsart plugin: generate and edit images, video and audio with Picsart AI, and turn your recordings, designs and ideas into finished short videos you review before export. Browse and organize your Picsart Drive. Generation requires a signed-in Picsart account and credits.

Language: English · Automatically detected from descriptions.

What changed

· 34 observations

Capabilities & instructions

Default prompt added: “Make a short drama series from my idea.”. Default prompts updated; open the comparison for details. Declared skill added: “make-cartoon”. Declared skill added: “social-posting”. 13 more changes in the comparison.

View comparison →
Capabilities & instructions

Skill instructions changed from “and reading a film's assets for a generation is `picsart_film_list_assets`.” to “reading a film's assets for a generation is `picsart_film_list_assets`, and showing or picking the user's saved scene documents (characters, locations,...”.

View comparison →
Capabilities & instructions

Skill instructions changed from “55.75.0 --- # Caption decoration authoring Choose the asset form from the behavior, not the visual appearance. | Need | Declare | Caption row | |---|---|---|...” to “55.128.2 --- # Caption decoration authoring Choose the asset form from the behavior, not the visual appearance. | Need...

View comparison →
Capabilities & instructions

Full description changed from “rig-face, their control names and ranges, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync — and the craft of...” to “rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync,...

View comparison →
Capabilities & instructions

Skill instructions: added “”.

View comparison →
Capabilities & instructions

Full description changed from “B-roll under a voice-over, an interview with B-roll, or a remix of a reference reel (a talking head or a skit included) - cut on the words, checked, choices...” to “channel clips from a long video or its link in the look of a short you bring, B-roll under a voice-over, an interview...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions: added “At the look stage the same reading, with `YLOW` (the black point) and `YHIGH` (the white point) added to the `grep`, is taken on the board's stills and on...”.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “open. - `deliver`: done only once `story`, `qc`, `critics` and `review` are done and the map was approved: its rows in `locked`, or an approval with `scope`...” to “open; a `channel-clips` record copies a look, not a...

View comparison →
Capabilities & instructions

Full description changed from “bought -” to “bought, with”. Skill instructions changed from “bought -” to “bought, with”.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “whole cast (at most 12 a board), each character's descriptor lines as `story`. Every card opens on those lines, so a board sent untouched changes nothing. It...” to “film's title as `film` and the whole cast (at most 12 a...

View comparison →
Capabilities & instructions

Skill instructions: added “The user picks the look: apply each of them to one representative scene and show the versions in `picsart_scene_picker`, each card labelled in their terms...”.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “assets and their” to “assets, their `identityReferences` and”.

View comparison →
Pricing references

Skill instructions: added “Apply picsart-video-rules's SPEND rule to each tool's billing contract.”.

View comparison →
Capabilities & instructions

Skill instructions changed from “is (picsart-video-rules's Asset URLs). Otherwise: - **A file on disk, and you can run shell commands:** call `picsart_upload_local_files` with each file's...” to “is, except a HEIC photo's (picsart-video-rules's Asset URLs). Otherwise: - **A file on disk, and you can run shell...

View comparison →
Capabilities & instructions

Skill instructions changed from “- **Create.** Images, videos and audio from a prompt, with a choice of models. They can pick a model themselves (`picsart_model_show`), and every creation is...” to “Their saved characters, locations, templates and looks (scene documents) open in the same browser with...

View comparison →
Capabilities & instructions

Skill instructions changed from “sampled on a contact sheet (free). Never ask for a style by its name alone.” to “side by side in `picsart_scene_picker` (free), each card labelled by how it looks to them ("paper and ink, friendly"), not by its id. Never ask for a style...”.

View comparison →
Capabilities & instructions

Skill instructions changed from “55.104.0 --- # Reuse and customize a catalog item Served checks: `picsart_scene_check_contracts` runs contract records and reusable templates,...” to “55.128.2 --- # Reuse and customize a catalog item Served checks: `picsart_scene_check_contracts` runs contract records and reusable...

View comparison →
Capabilities & instructions

Skill instructions: added “Coordinates A scene built by hand goes wrong first in its coordinates: - **A shape layer inside a composition starts at that composition's centre.** Set its...”.

View comparison →
Capabilities & instructions

Skill instructions changed from “55.104.0 --- # Saying motion in a scene The decision — what a beat is for, how long, which register — is `picsart_scene_recipe motion-intent`. This is the...” to “55.128.2 --- # Saying motion in a scene The decision — what a beat is for, how long, which register — is...

View comparison →
Pricing references

Supporting files updated; open the comparison for details. Skill instructions changed from “--- # Reel structure A reference reel lends its **structure**: where its beats fall, how its shots and captions work, how fast it talks, what sits under the...” to “local-scripts: pick_style.py, style_check.py, build_index.py...

View comparison →
Capabilities & instructions

Skill instructions: added “For generated replacements, follow picsart-video-rules's Image generation and supplied photos: keep its image default or the user's explicit model, and pass...”.

View comparison →
Capabilities & instructions

Skill instructions changed from “2.4.0 Built at: 2026-11-06T15:47:40.556Z Source revision: 1d90792” to “2.5.0 Built at: 2026-11-10T14:56:03.599Z Source revision: 24b3ba2”.

View comparison →
Pricing references

Skill instructions changed from “Tools Tools are named here by their server names, such as `picsart_scene_export`. The host may show them with a prefix; call the one whose name ends in the...” to “Image generation and supplied photos Every flow defaults to GPT Image 2.6 Sunburst (`gpt-image-2.6-sunburst`) for image...

View comparison →
Capabilities & instructions

Full description changed from “story - several scenes, recurring characters, one locked look - staged and approved step by step, drafted as an animatic before video. Use when the user...” to “story, with recurring characters, one look and approved cast/location references, then draft video and a reviewed cut....

View comparison →
Pricing references

Full description changed from “and turn the measurement into scene keyframes; then measure your own render the same way and compare the two with picsart_media_track_motion_diff. Covers...” to “work out each move's easing (curve, overshoot, bounce) and turn it into scene keyframes; then measure your render the same...

View comparison →
Capabilities & instructions

Full description changed from “move.” to “move, and before reporting that your own render, character, rig or acceptance video works.”. Skill instructions changed from “move. metadata: category: workflow version: '1.0' ported-from: motion-review 1.0 at 55.75.0 --- # Review motion in an existing scene Review the...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions: added “**When two or more could fit and it's taste, the designer picks.** Build 2–6 candidates on the real element and open them in `picsart_scene_picker` — one...”.

View comparison →
Capabilities & instructions

Full description changed from “book of drawn pages, an illustrated tale, an animated video, a motion episode,” to “of drawn pages, an illustrated tale, a video comic or video tale,”. Supporting files updated; open the comparison for details. Skill instructions changed from “book of drawn pages, an illustrated tale,...

View comparison →
Capabilities & instructions

Skill instructions changed from “those lines. Then act on `film_cast_chooser_feedback` as film-cast-design's The starting point says: `story` keeps your draft, `preset` and `person` pass...” to “the ready-made characters, with the look you `suggested` picked, and keeps your lines on its story tab. Then act on...

View comparison →

Technical updates · 2

Supporting file metadata differs

View technical comparison →

Package or technical metadata updated

View technical comparison →

· 45 observations

Capabilities & instructions

Skill instructions: added “ported-from: motion-intent 1.2 at 55.75.0”.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions: added “Tuning by hand — `picsart_scene_tune` **When:** one rule, here only. A declared knob goes to the tuner at the first taste complaint ("too much glow",...”.

View comparison →
Capabilities & instructions

Skill instructions changed from “film-cutting, film-finishing, retention-hooks, spoken-captions, background-music, scene-building-basics, quality-review, realistic-color-grade,...” to “film-animatic, film-cutting, film-finishing, footage-reframing, retention-hooks, spoken-captions, background-music,...

View comparison →
Capabilities & instructions

Full description changed from “website into finished videos - several standalone how-to shorts for Reels, TikTok or Shorts that each teach one easy thing, a feature explainer, a promo with...” to “site into videos - standalone how-to shorts for Reels, TikTok or Shorts each teaching one easy thing, a feature...

View comparison →
Capabilities & instructions

Skill instructions changed from “--- # Layout relationships through motion Served checks: `picsart_scene_check_contracts` runs contract records and reusable templates,...” to “ported-from: layout-choreography 1.7 at 55.75.0 --- # Layout relationships through motion Served checks: `picsart_scene_check_contracts` runs...

View comparison →
Capabilities & instructions

Skill instructions: added “ported-from: large-scene-authoring 1.1 at 55.75.0”.

View comparison →
Capabilities & instructions

Skill instructions changed from “| Stage | Gate | Skills | |---|---|---| | 1. The account and the credits | — | — | | 2. Open Picsart, when the host has it | ASK | open-picsart-app | | 3....” to “Before acting on a stage, load the skills in its row that apply to this job, also when the work resumes there. | Stage |...

View comparison →
Capabilities & instructions

Full description: added “or product photo”. Skill instructions changed from “- remove or replace its background, enhance or upscale it, or turn it into a vector - with a model that fits, its settings checked and its price quoted...” to “or product photo - remove or replace its background, enhance or upscale it, or...

View comparison →
Capabilities & instructions

Full description changed from “following the person, measured once per source, and cut it into a reel of clips back to back with scripts/reel_cut.py, so any re-cut is free. Covers which...” to “on the right person - measured once per source, checked and corrected by hand where the tool fails (a subject cut off, the...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “story | | `references/dialogue.md` | write a spoken line | | `references/breakdown.md` | turn the story into shot cards and asset tags | |...” to “story, or its viewer track | | `references/dialogue.md` | write a spoken line...

View comparison →
Capabilities & instructions

Skill instructions changed from “`acceptsImage: true`, `concise: false`. Keep the rows whose `supportedAspectRatios` hold the film's ratio. Edits, extends and upscalers are out.” to “`concise: false`. Keep the rows whose `supportedAspectRatios` hold the film's ratio. Edits, extends and upscalers are out. Never...

View comparison →
Capabilities & instructions

Full description changed from “notes,” to “notes ("fix my film"),”. Skill instructions changed from “notes, or a join between two shots is repaired. --- # Film edit The cut is built from the selects, never from the raw pile, and it stays editable: clips, not...” to “notes ("fix my film"), or a join between two shots...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “sheet: front face, side face, full-body outfit, and a states row when the story needs one | `picsart_film_compile_prompt`, `kind: "sheet"` | | A person the...” to “sheet, the strip of Picsart's canvas: full-body front, side...

View comparison →
Capabilities & instructions

Full description: added “A Figma design made into a finished video starts in animate-design.”. Skill instructions changed from “metadata: version: '1.3'” to “A Figma design made into a finished video starts in animate-design. metadata: version: '1.3' ported-from: figma-storyboard-to-scene 1.3 at 55.75.0”.

View comparison →
Capabilities & instructions

Skill instructions changed from “--- # Writing a transition A transition is DATA: a JSON definition, declared inline as a `type: "transition"` asset. This is what the definition has to say,...” to “ported-from: transition-authoring 1.0 at 55.75.0 --- # Writing a transition A transition is DATA: a JSON definition,...

View comparison →
Capabilities & instructions

Skill instructions changed from “--- # Caption decoration authoring Choose the asset form from the behavior, not the visual appearance. | Need | Declare | Caption row | |---|---|---| |...” to “ported-from: caption-decoration-authoring 1 at 55.75.0 --- # Caption decoration authoring Choose the asset form from the...

View comparison →
Capabilities & instructions

Skill instructions changed from “saved transcript by its asset id: a clip of the reel, a voice-over layer or a presenter's take alike, nested panels and bubbles included (the scene's own id...” to “transcript (its file, where you run commands) by its asset id: a clip of the reel, a voice-over layer or a presenter's...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions: added “ported-from: ui-motion 1.11 at 55.75.0”.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “figma-storyboard-animation, motion-intent, motion-pattern-library, scene-animation-reference, custom-transitions, app-ui-animation, photo-slideshow,...” to “character-rigging, figma-storyboard-animation, motion-intent,...

View comparison →
Capabilities & instructions

Default prompt removed: “Make a short drama series from my idea.”. Default prompts updated; open the comparison for details. Declared skill added: “asset-audit”. Declared skill added: “assets”. 34 more changes in the comparison.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “## The transcript 1. **Probe before you transcribe.** Check `hasAudio` from `picsart_media_probe` first, and skip only when it reports `hasAudio: false`, as...” to “A caption carries only what is said: never a speaker's name...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “saved as `transcript-<source id>.json`, which sets every boundary, and a watch, which picks the moments. A photo has no speech at all: it is a beat, not a...” to “kept as the tool returned it (`transcript-<source id>.json`...

View comparison →
Capabilities & instructions

Skill instructions changed from “From this skill's folder, run `python3 scripts/safe_zone.py <file>` on `{ scene, destination }`, with `destination` one profile or a list of them. It prints...” to “Where you cannot run commands, the safe zone is `open`. From this skill's folder, run `python3 scripts/safe_zone.py...

View comparison →
Capabilities & instructions

Skill instructions: added “Where you cannot run commands, never hunt for a shell: leave the actions to the use case's build, which stops as picsart-video-rules says for a script that...”.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “'1.6' --- # Reuse and customize a catalog item Served checks: `picsart_scene_check_contracts` runs contract records and reusable templates,...” to “'1.7' ported-from: template-customization 1.7 at 55.104.0 --- # Reuse and...

View comparison →
Capabilities & instructions

Skill instructions: added “## Reusable parts When you build a custom character or a part the user may want to adjust, declare root `parameters` for the knobs they will want (pose,...”.

View comparison →
Capabilities & instructions

Full description changed from “depth and the composition camera, motion blur, and transition firing. Use when motion needs authoring or validation,” to “named actions mixed on a placed scene, depth and the composition camera (2.5D, cards that flip or fan out in depth under an orbit, a 2D film camera's pan,...”....

View comparison →
Capabilities & instructions

Skill instructions changed from “own. - **Payoff:** the sentence that answers the hook. **Never use the payoff as the hook**: it closes the loop before it opens. Lead with the question, end...” to “own: a cold reader of the heard script says whether it does, not you (the speech-aware-cutting skill). - **Payoff:**...

View comparison →
Capabilities & instructions

Full description: added “A whole recreation starts in recreate-video.”. Skill instructions changed from “--- # Fragment matching” to “A whole recreation starts in recreate-video. --- # Fragment matching **This skill is a stage of the recreate-video use case.** Before you act on a...”.

View comparison →
Capabilities & instructions

Full description changed from “Copy a reference reel's structure, never its content - read its beats, shots, caption pattern, pace and sound bed into a structure sheet (or parse a written...” to “Read a reference reel's structure and format, never its content - its beats, shots, caption pattern, pace and bed into a...

View comparison →
Capabilities & instructions

Full description changed from “"copy this animation", "rebuild this promo with my product").” to “"reuse my own ad", "copy this animation", "rebuild this promo with my product"), or carries on a recreation already under way.”. Skill instructions changed from “"copy this animation", "rebuild this promo with my...

View comparison →
Capabilities & instructions

Skill instructions changed from “'1' --- # Colour realism with `ai_realism` `ai_realism` is the look for "make the colours more realistic". It runs the three passes an editor does by hand on...” to “'1.1' ported-from: color-realism 1.1 at 55.75.0 --- # Colour realism with `ai_realism` `ai_realism` is the look for...

View comparison →
Capabilities & instructions

Skill instructions: removed “**Optional: the editable project.** `picsart_scene_translate` returns the scene as a full engine project, with each transition wired at its seam. Skip it...”.

View comparison →
Capabilities & instructions

Full description changed from “short's script, hook and draft reviewed by a simulated viewer panel and” to “draft watched cold by model viewers against its viewer track, then reviewed by”. Supporting files updated; open the comparison for details. Skill instructions changed from “short's script, hook and draft...

View comparison →
Capabilities & instructions

Skill instructions changed from “2.3.0 Built at: 2026-11-03T11:41:23.572Z Source revision: dfa2890” to “2.4.0 Built at: 2026-11-06T15:47:40.556Z Source revision: 1d90792”.

View comparison →
Capabilities & instructions

Skill instructions changed from “## Tools Tools are named here by their server names, such as `picsart_scene_export`. The host may show them with a prefix; call the one whose name ends in...” to “A use case's stage table names the skills each stage loads. Before you act on a stage, load the skills in its row that...

View comparison →
Capabilities & instructions

Skill instructions changed from “--- # Photo promo / slideshow Assumes the font asset from picsart_scene_fonts (a `live.fonts` entry), and that picsart_scene_patch returns the patched scene...” to “ported-from: photo-promo 1 at 55.75.0 --- # Photo promo / slideshow Assumes the font asset from picsart_scene_fonts (a...

View comparison →
Capabilities & instructions

Full description changed from “step.” to “step, drafted as an animatic before video.”. Supporting files updated; open the comparison for details. Skill instructions changed from “step. Use when the user wants a short film, a movie or a multi-scene story ("I have a script"), or carries on a film already under way...

View comparison →
Capabilities & instructions

Skill instructions changed from “--- # Motion extraction `picsart_media_track_motion` recovers what objects **visibly do** in a flattened video: their position, rotation and scale on every...” to “metadata: ported-from: motion-extraction unversioned at 55.75.0 --- # Motion extraction `picsart_media_track_motion`...

View comparison →
Capabilities & instructions

Skill instructions changed from “--- # Motion across beats and seams Served checks: `picsart_scene_check_contracts` runs contract records and reusable templates, `picsart_scene_check_motion`...” to “ported-from: motion-continuity 1.1 at 55.75.0 --- # Motion across beats and seams Served checks:...

View comparison →
Capabilities & instructions

Full description changed from “and drawn strokes.” to “drawn strokes, and cartoon fast motion (smears, multiples, speed lines).”. Supporting files updated; open the comparison for details. Skill instructions changed from “and drawn strokes. Use when the motion intent is known and you need supported scene properties...

View comparison →

Technical updates · 2

Supporting file metadata differs

View technical comparison →

Package or technical metadata updated

View technical comparison →

· 29 observations

Capabilities & instructions

Declared skill added: “app-ui-animation”. Declared skill added: “custom-transitions”. Declared skill added: “figma-storyboard-animation”. Declared skill added: “large-scene-assembly”. 21 more changes in the comparison.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “resting-frame-rules title: Animate a design short-description: Turn a design or your assets into a motion video argument-hint: '[Figma link, design or...” to “resting-frame-rules, figma-storyboard-animation, motion-intent,...

View comparison →
Capabilities & instructions

Skill instructions changed from “"mpscene://sparkle_badge"},” to “"scene://sparkle_badge"},”.

View comparison →
Capabilities & instructions

Full description changed from “a clip or highlights” to “podcast clips, a highlight reel, a montage or a photo slideshow”. Supporting files updated; open the comparison for details. Skill instructions changed from “a clip or highlights from it ("make a reel from this", "cut a 30-second short", "find the best...

View comparison →
Capabilities & instructions

Skill instructions changed from “to confirm the running order. ## Set the format — the Motion Setup console Open **`picsart_scene_setup` once, at the start**, prefilled so it opens on the...” to “(with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “Check each with `picsart_film_verify_prompt` on the literal arguments, with its token. A failure is fixed in the inputs and compiled again. 4. Sheets are...” to “Compile with `verifyWith` (`request` with the `imageUrls` you...

View comparison →
Capabilities & instructions

Full description changed from “how generated footage cuts, every shot a window over its run's file, the montage bootstrap with hard cuts, separate dialogue and ambience, cleanup of named...” to “every generation one clip as generated, never split or trimmed, the montage bootstrap with hard cuts, separate dialogue...

View comparison →
Capabilities & instructions

Full description changed from “final-resolution pass from the saved prompts,” to “draft takes finished to full quality,”. Supporting files updated; open the comparison for details. Skill instructions changed from “final-resolution pass from the saved prompts, colour matched and graded from the scene tools' looks,...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “it, and the take is split back into shots at the cuts it actually made. Read these before the step: | File | Read it before you… | |---|---| |...” to “it. The cuts it actually made are found and checked against the plan, and...

View comparison →
Capabilities & instructions

Full description: added “when a landscape video is reposted as a vertical one,”. Skill instructions: added “when a landscape video is reposted as a vertical one,”.

View comparison →
Capabilities & instructions

Full description: added “Load it first, before any tool, when they say not to ask, to work unattended, or set a spend limit. Load it before calling any Picsart model, generation or...”. Skill instructions changed from “metadata: uses: film-shot-generation title: Generate media short-description: Make or edit images,...

View comparison →
Capabilities & instructions

Skill instructions: added “(with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step...”.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “SPEND | screen-recording-analysis, footage-analysis | | 4. The set: which videos | SHOW, ASK | screen-recording-analysis, screen-recording-layouts | | 5. How...” to “— | screen-recording-analysis, footage-analysis | | 4. The...

View comparison →
Capabilities & instructions

Full description: added “a story reel,”. Skill instructions changed from “microdrama, web series or its next episode. Not for a one-off film (movie-producer). metadata: uses: drama-series-writing, film-story-writing,...” to “a story reel, microdrama, web series or its next episode. Not for a one-off film...

View comparison →
Capabilities & instructions

Skill instructions changed from “The tool replies with a job receipt by default: follow it as picsart-video-rules says, and start every tracking job a step needs before you follow any....” to “Neither `picsart_media_track_motion` nor `picsart_media_track_motion_diff` is a SPEND unless its description says it charges...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “realistic-color-grade optional: realistic-color-grade title: Produce a short film short-description: Make a short film from your story, scene by scene...” to “realistic-color-grade, sd25-pe, sd2-pe optional:...

View comparison →
Capabilities & instructions

Skill instructions changed from “ASK:” to “ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the...”.

View comparison →
Capabilities & instructions

Skill instructions changed from “`mpscene://montage` (`picsart_scene_capabilities`, section `template:mpscene://montage`)” to “`scene://montage` (`picsart_scene_capabilities`, section `template:scene://montage`)”.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “and every review. Pace changes how often you ask, never a safeguard. ## Asking The questions themselves are in each use case. This is how every one of them...” to “no stated spend limit covers and every review. Pace changes...

View comparison →
Capabilities & instructions

Skill instructions changed from “2.2.0 Built at: 2026-10-26T12:51:38.141Z Source revision: 2590ad6e43” to “2.3.0 Built at: 2026-11-03T11:41:23.572Z Source revision: dfa2890”.

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions: added “a film's cut is reviewed.** From this skill's folder, run `python3 scripts/cut_check.py <file>` on `{ scene, allowed?, shots?, places? }`: the cut's scene,...”.

View comparison →
Capabilities & instructions

Skill instructions changed from “quality-review title: Recreate a video short-description: Rebuild a reference video with your own photos and text argument-hint: '[reference video, your...” to “quality-review, background-music optional: background-music title: Recreate a video short-description: Rebuild a reference...

View comparison →
Capabilities & instructions

Supporting files updated; open the comparison for details. Skill instructions changed from “grids). Live action, kinetic typography, particles, 3D and character animation are out of reach. Say so before building, rather than deliver a...” to “grids) **and illustrated templates** (photo or clip slots dressed with...

View comparison →
Capabilities & instructions

Skill instructions: added “Overlays **An overlay never blinks.** When a caption, a title or a sticker follows another in the same place, start it where the last one ends, and never let...”.

View comparison →
Capabilities & instructions

Skill instructions: removed “Whether a call charges is picsart-video-rules's SPEND; the use case asks before the read.”.

View comparison →

Technical updates · 2

Supporting file metadata differs

View technical comparison →

Package or technical metadata updated

View technical comparison →

· 5 observations

Capabilities & instructions

Full description changed from “the film — colour unification and grade, the soundtrack decision (keep generation audio, add a music bed, or hand off to a sound team), the final-resolution...” to “a film after picture lock - the final-resolution pass from the saved prompts, colour matched and graded from the scene...

View comparison →
Capabilities & instructions

Full description changed from “Create and edit images, videos, audio, and text with Picsart AI models. Compose and render media scenes, inspect model parameters and credit estimates, track...” to “The official Picsart plugin: generate and edit images, video and audio with Picsart AI, and turn your recordings,...

View comparison →

Technical updates · 2

Package or technical metadata updated

View technical comparison →

Package or technical metadata updated

View technical comparison →

· 3 observations

Capabilities & instructions

App-6a18d4c190a0819186e6b129a09e931e updated; open the comparison for details. Picsart-gen-ai updated; open the comparison for details. Capabilities updated; open the comparison for details. Screenshot urls updated; open the comparison for details. 12 more changes in the comparison.

View comparison →
Capabilities & instructions

App-6a18d4c190a0819186e6b129a09e931e updated; open the comparison for details. Picsart-gen-ai updated; open the comparison for details. Capabilities updated; open the comparison for details. Screenshot urls updated; open the comparison for details. 11 more changes in the comparison.

View comparison →

Technical updates · 1

Package or technical metadata updated

View technical comparison →

Keywords

Files & skills

File archives

Plugin package436 files · 1.26 MBBrowse files →
Skill instructions
ai-presenter5.81 KB

View saved version →

---
name: ai-presenter
description: Put a generated presenter on screen and keep them honest - lip-sync (the face on screen says the audio that plays), one take on the whole step narration, the head bubble and the head-and-screen split, the inputs for the avatar take (the voice is the voice-over-generation skill's), and the presenter's portrait - how to write it and how to check it before a take. Use when a video needs an on-camera presenter made from a portrait photo and a voice.
---

# Talking head

A promo where the presenter disappears after the hook loses the human thread. Keep them present in
some of the steps — as the top band of a head-and-screen split, or as a round bubble over the panel.

| Read this | Before you |
|---|---|
| `references/portrait.md` | write the presenter's portrait, or start a take from a portrait |

## Lip-sync

**The face on screen must be saying the audio that is playing.** A talking head over a voice line
it did not speak is visibly out of sync and reads as fake. So:

- If the presenter appears during the steps, generate **one** `kling-avatar` take on the **whole
  step narration** (one voice line holding every step line, the same voice as the hook), and use
  that take for every on-screen step, trimmed to each step's sentence (the transcript's word times
  give the ranges; see the spoken-captions skill). The take's own audio is the step voice-over: **unmute
  the presenter layer and add no separate audio layer for that step**. Only one layer plays it at a
  time.
- If the budget covers only the hook take, the presenter does not appear in the steps. Never loop
  the hook take or freeze a frame as a stand-in.
- Price the longer take alongside the hook take. Whether the presenter appears in the steps is the
  user's choice, and the use case asks it.

## The voice and the take

- **Voice.** The voice lines are made as the voice-over-generation skill says. When the presenter appears in
  the steps, the step lines are one line instead (above).
- **Presenter.** An on-camera line is a `kling-avatar` take through `picsart_generate`: one face
  portrait (`imageUrls`) plus that line's voice as the speech audio — the catalog names it
  `audioUrl`, singular and required. `picsart_generate` has no field of that name: it goes in
  `extra`, with every other setting `picsart_model_params({ model: "kling-avatar" })` lists, under
  the exact names it gives rather than names from memory. There is no duration
  parameter: the clip runs as long as its audio, so the line's length IS the clip's length. Quote
  each take with `picsart_preflight`. Before its voice line and portrait exist it may not price;
  then quote it as a paid call whose amount is not known in advance (picsart-video-rules, SPEND), and never
  generate its inputs to get a number. Keep on-camera lines few: takes are slow and paid.
- **Portrait.** Every take inherits its portrait's flaws, so the portrait passes the check in
  `references/portrait.md` before any take is generated, whether it was generated or uploaded.

## Head bubble

**Head bubble.** The presenter clip, `fit: "contain"`, framed on the face with the screen-recording-layouts skill's
panel formula (scale up so the face fills the circle; `cover` would crop the face away when the
clip is landscape and the face is off its centre), masked with a `rect` whose `roundness` is half its size (a circle; ≈ 300–340 px at 1080
wide), with a 4–6 px rim shape behind it. Place it in a panel corner that the step's focus point
never visits, outside the platform's UI zones (the right-hand action rail and the bottom caption
area on TikTok and Reels) and clear of the caption band. If the focus moves into its corner, move
the bubble to the opposite corner at a cut, never during a zoom. Enter it with a 0.25 s fade and a
scale from 0.85 (the rim is a shape, so fade it with `opacity` keyframes; the fade presets do not
apply to a shape layer); it holds still while the recording zooms, so the eye has one fixed poi

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

Referenced files: 1 — file references are metadata, not package contents.

animate-design42.9 KB

View saved version →

---
name: animate-design
description: Turn static material into a real motion-designed video — a Figma design's LAYERS, or the user's own uploaded assets (photos, logos, screenshots, clips), become a composed, animated ad/reel where elements slide, scroll, type on, parallax, and smart-animate, tuned by eye, then rendered — or add designed motion to a video that already exists. The user can describe the motion they want, or let the skill analyze the assets and propose a concept. Use when the user wants to animate a design or assets, "make an ad/reel/video from these images/frames/screens", add motion to a Figma flow, bring static material to life, or add an animated intro, title card, transition, morph, callout or logo reveal to a tutorial, walkthrough, promo or reel. Not for cutting the user's footage into an edit, and not for generating footage from a pure text idea (that's generate-media); the motion inside such a video still comes here.
metadata:
  owner: motion-designer
  uses: design-layer-import, motion-design-craft, resting-frame-rules, character-rigging, figma-storyboard-animation, motion-intent, motion-pattern-library, scene-animation-reference, scene-3d-authoring, custom-transitions, app-ui-animation, photo-slideshow, asset-audit, motion-review, quick-merge-and-export, scene-template-remix, large-scene-assembly, linked-element-motion, motion-scene-continuity
  optional: character-rigging, scene-3d-authoring, asset-audit, motion-review
  title: Animate a design
  short-description: Turn a design or your assets into a motion video
  argument-hint: '[Figma link, design or assets]'
  starter-prompt: Animate my design into a short motion video.
---

# Motion — a static design becomes a motion-designed ad

The frames are not the video. They are a **design**, and a design is made of **layers**:
panels, headlines, buttons, images, lists. Motion design animates those *elements* — a
list scrolls, a headline types on, a card slides in with a stagger, a tap-dot pulses,
the shared chrome **smart-animates** from one screen to the next, everything moving with
depth. Bind a frame as one flat PNG and all of that is impossible — you get a slideshow.

So the first principle of this pipeline: **the design comes in as layers, and the video
is a composite of moving elements — never a montage of flat screens.** A real ad is
built the way the After-Effects reference is built: each element on its own layer, each
with its own motion, shared elements carried between frames.

One economic law runs underneath: **the motion loop is free; the one paid capability is video
generation, and it is always credit-gated.** Every tool the compose/motion/preview loop touches —
layer ingest, compose/`patch_scene`, layout queries, `validate`, the panel, and the renders
themselves (`picsart_scene_export`, `picsart_scene_contact_sheet`) — is on the connector's
zero-credit list (verified against live billing), so for all of that: **never tell the designer an
action will cost credits, and never hesitate to render for cost reasons — there is no cost.** The
**sole exception** is **generating video** (`picsart_generate` and the generative tools), which spends
credits — and it **never runs without the designer's explicit, informed consent**: show the balance,
quote the exact cost and SPEND (quote it in one line, then get the yes as an ASK with "Yes, go ahead" / "Yes, up to N credits for this task" / "No": the host's own choice tool where it offers one, otherwise those options numbered in one message; the host's own confirmation before a tool runs is not this yes; unless a spend limit the user stated covers it: N credits or an explicit no-limit ("as much as needed"), never inferred from words like "go ahead". Within it, ask nothing: quote it in one line ("About 8 credits; 12 of 20 left after this"), call it, then say what it spent and what remains, keeping a running total that includes failed calls, and stop to ask before the first call that would cross it. A money am

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

Referenced files: 8 — file references are metadata, not package contents.

app-ui-animation14.9 KB

View saved version →

---
name: app-ui-animation
description: Build a phone or web UI in a scene with scrolling, carousels, button feedback, cursor paths and clicks, context menus, drag-and-drop, synchronized controls, bottom sheets and frosted-glass panels. Use when animating an app mockup, UI walkthrough, slider or onboarding flow, frosted glass or glassmorphism cards, or when a mock renders correctly but reads as a picture rather than an app somebody is using.
metadata:
  category: authoring
  version: '1.11'
  ported-from: ui-motion 1.11 at 55.75.0
---

# UI motion — making a mockup behave like a device

A UI mock that renders correctly and still reads as a screenshot is almost always missing
three things: the content does not carry momentum, nothing answers a touch, and panels
appear instead of arriving. Each has a home in the catalog. **Read this before authoring a
new preset for a UI beat — most UI beats are arrangements of what already exists.**

## Where a UI beat belongs

Before choosing a preset, settle the semantic units and who owns their motion with
linked-element-motion (fetch with `picsart_scene_recipe`, name `linked-element-motion`); it also
covers the ownership/binding/phase decision, growing panels and sibling reflow. Derive backing
dimensions and child placement from shared parameters so a size edit preserves the layout by
construction; grouping does not make a container automatically fit its animated children. Validate
those relationships throughout the event window.

| Home | When |
|---|---|
| **Motion preset** or **Look** | Choose between them with motion-pattern-library (fetch with `picsart_scene_recipe`, name `motion-pattern-library`). Only a look adds structure the layer does not have — a viewport, a mask, extra layers (`scroll`, `rounded_corners`) |
| **Scene template** | The motion depends on a layer's index or count (a list stagger, a grid) |
| **This recipe** | No new capability — a known-good arrangement of the above |

And before adding any of them: **prefer a param on an existing preset over a new preset.**
Paged scrolling is `snap` on `scroll`, not a `carousel` look. A catalog that grows one entry
per arrangement stops being scannable, and then finding costs more than building.

## Build the chrome from shapes

UI chrome is rectangles with rounded corners and text on top. Author it as `kind: "shape"` —
it is built in. Do **not** reach for an SVG data-URI; it
costs you a rasterised asset, a URI-encoding trap, and animatable geometry.

A button, as a scene asset so the whole thing can be referenced and pressed as one unit:

```json
{ "type": "scene", "scene": {
  "version": "1.0",
  "composition": { "width": { "$eval": "width" }, "height": { "$eval": "height" }, "duration": 6, "fps": 30, "background": "#00000000" },
  "parameters": {
    "width": { "type": "number", "default": 560, "min": 300, "max": 1000 },
    "height": { "type": "number", "default": 104, "min": 80, "max": 200 }
  },
  "layers": [
    { "id": "bg", "content": { "kind": "shape", "items": [
        { "type": "group", "contents": [
        { "type": "rect", "size": [{ "$eval": "width" }, { "$eval": "height" }], "position": [0, 0], "roundness": { "$eval": "height / 2" } },
          { "type": "fill", "color": "#111111ff" } ] } ] },
      "transform": { "position": [{ "$eval": "width / 2" }, { "$eval": "height / 2" }] } },
    { "id": "lb", "content": { "kind": "text", "text": "Continue",
        "font": { "family": "helvetica-bold", "size": 40 }, "color": "#ffffffff", "alignment": "center" },
      "transform": { "position": [{ "$eval": "width / 2" }, { "$eval": "height / 2" }] } } ] } }
```

Store this as a scene asset and place a `scene_ref` with `fit:"none"`, binding `width`/`height`
on that reference. Animate the reference once for shared motion and opacity. The formulas resolve
when the instance is assembled; after expanding/baking the reference, its geometry is concrete and
later parameter edits do not remain live. Re-resolve the source for a ne

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

Referenced files: 5 — file references are metadata, not package contents.

asset-audit6.25 KB

View saved version →

---
name: asset-audit
description: Audit media assets BEFORE they enter scene cards, boxes or looks - alpha padding, dimensions, aspect, video properties, URL-reuse hazards, and whether a photo in a reference is a masked view of a larger one. Use before authoring scenes with new assets or when a styled card renders with mysterious edges or misalignment.
metadata:
  category: workflow
  version: '1'
  ported-from: asset-audit 1 at 55.75.0
---

# Asset audit - check the media before blaming the scene

Most "the mask is broken / content is misaligned / corners aren't rounded" reports are ASSET
problems. Audit first; it takes a minute and saves a debugging afternoon.

## The checklist

1. **Alpha padding (the #1 trap).** Sticker-style PNGs bake transparent margins into the canvas:
   `fit: cover` covers the box with the FULL canvas, so the visible content sits inset and any
   rounding or mask lands in the transparent margin - the visible edge is the asset's own square
   boundary. Check it by looking: build a one-layer scene whose composition is the asset's own size
   (from `picsart_media_probe`), `background: "#ff00ffff"`, the asset with `fit: "contain"`, and
   look at it with `picsart_scene_contact_sheet` (`resolution` set to the composition size). No
   magenta inside the frame: clean. Magenta around the subject: a padded sticker; trim it, or use
   it deliberately as a decal with no look.
2. **Dimensions and aspect:** `picsart_media_probe` (no download; EXIF-corrected width and height,
   duration for video). Cover-fit crops from decoded dimensions - a 4:3 photo in a 9:16 card loses
   its sides; check the subject survives the crop. Also compare the asset's size with its largest
   placement box: `scale = max(box_w / own_w, box_h / own_h)`, and a scale above 1 is an upscale. A
   585x1024 photo in a 1080x1920 full-bleed box is stretched to nearly double. Rendering can decode
   an asset whose dimensions are omitted, but query and selection geometry cannot invent them: for
   `fit: "none"`, declare both `width` and `height` when the layer must be selectable or
   queryable, or use its intrinsic centre as the default transform anchor. Without them the source
   still renders at natural size, but `picsart_scene_query_layout` returns no bounds and the
   fallback pivot is the content origin. Do not add `content.bounds` as a workaround: `fit: "none"`
   has no destination box and rejects `bounds` and `align`. When a scene already declares an
   asset's `width`/`height`, compare them with the probe: a mismatch means the document describes
   a different file than the one that will load.
3. **Video specifics:** duration against the trim window you plan (a trim beyond the end freezes
   the last frame); first frames may decode dark or blank, so don't trim in exactly at 0 or at a
   scene cut; embedded audio (mute it unless wanted); reversed playback does NOT reverse audio.
4. **URL reuse:** fine. The same media URL in two different boxes renders correctly. Do NOT add a
   distinct `#fragment` per instance: it defeats content dedup, and it silently rewrites a URI that
   already carries a fragment of its own.
5. **SVG data-URIs:** encode only `< > space`; raw spaces in interpolated text are tolerated, raw
   `#` is not (colours as hex-without-# interpolated after `%23`). Declared width and height on the
   asset matter - undeclared dimensions break mask plus bounds combinations.
6. **Content vs box semantics:** an asset that is itself a full-bleed photo behaves under any fit;
   UI screenshots and renders with baked-in margins do not - measure where the content actually
   starts.

## Is the reference element MASKED?

When sourcing assets for a recreation of a reference video, decide for every photographic element
whether you are looking at a WHOLE asset or a MASKED VIEW of a larger one. Baking the mask into the
bitmap gives the right pixels and the wrong scene: the photo can no longer be swapped, the mask
cannot animate, and the "a

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

assets2.99 KB

View saved version →

---
name: assets
description: Open the Picsart Assets panel on what the user made with Picsart - their videos, images, audio, film characters, film props and film projects - newest first, with previews, or on one kind or one film when they name it. Use when the user wants to see what they made ("show my assets", "my film characters", "open the two-sisters film") or asks for the assets panel. Not for browsing Drive folders, and not for choosing a film's references for a generation.
metadata:
  title: Browse assets
  short-description: See your videos, images, audio, characters and films
  argument-hint: '[videos | images | audio | characters | props | a film]'
  starter-prompt: Show my Picsart assets.
---

# Browse assets

Read picsart-video-rules first. One job: open the Assets panel on what the user asked to see.
Nothing here charges credits.

| Stage | Gate | Skills |
|---|---|---|
| 1. Open the panel | ASK | — |
| 2. One line | — | — |

## 1. Open the panel

Call `picsart_film_show_assets`, read-only and free:

- **Nothing named:** call it with `{}`. Every kind opens, one tab per kind.
- **One kind named:** call it with `type`: `video`, `image`, `audio`, `character`, `prop`, or
  `project` for their films or projects.
- **A film named:** call it with `{ "type": "project", "pageSize": 128 }` first. Find the film by
  its name among the projects it returns; while none fits and the reply says `hasNext`, call it
  again with the next `page`. Then call it with that project's `uid` as `projectUid`, and with
  `type` too when they asked for one kind of that film ("the characters of the garage film").
  When two films fit the name, ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says) which one, with their names as the options. When no page
  has it, say in one line that no film has that name, and stop.

Pass a `projectUid` only as a `type: "project"` reply gave it: the panel refuses any other folder.
When the tool says the user is not signed in, or that Drive is unavailable, say so in one line.

This panel is for looking. Browsing Drive folders is `picsart_drive_list`, reading a film's
assets for a generation is `picsart_film_list_assets`, and showing or picking the user's saved scene
documents (characters, locations, templates, looks…) is `picsart_scene_library_list`: it opens the
picker, and a picked card comes back as `libraryId`, `sceneUrl` and `kind`, to open with the scene tools
or use with `picsart_scene_apply_preset` (`library:<id>`) or `picsart_scene_apply_template`.

## 2. One line

The panel already shows every file. Say in one short sentence what is open ("Your film characters
are open."), and never list the files back, by name or by count.

Referenced files: 1 — file references are metadata, not package contents.

background-music4.9 KB

View saved version →

---
name: background-music
description: Draft, generate and lay an instrumental music bed under a finished video's speech - a five-slot brief read off the video, one generation on a music model from the catalog, and the bed mixed with scripts/music_bed.py so it dips under every spoken line and returns between them, with how to move its levels. Use when a final cut gets music under it, when a brief is redrafted for a steer, or when a laid bed sits too loud or too soft.
---

# Music bed

A talking video is often nearly done and still feels dry: no energy between the lines, dead air
at the seams. A bed fixes that, as long as it stays under the voice. Drafting the brief costs
nothing; the generation charges credits.

## The brief

**Draft it on the final picture.** A bed scored on a cut that is still changing is scored twice.

Draft the brief from what the video already tells you, in two or three lines, so it can be read
whole before anything is generated.

A brief names five things, and a model guesses whatever is missing:

| Slot | From | Example |
|---|---|---|
| Genre | the transcript's tone, not its topic | warm lo-fi hip-hop |
| Instruments | the genre | mellow Rhodes, upright bass, soft vinyl crackle |
| Tempo and energy | the picture's pace | around 90 BPM, unhurried |
| Mood | what is said, and how | intimate and reflective |
| **Purely instrumental**, in positive words | always | purely instrumental throughout, carried by the instruments above |

End it with what the bed is for: "sits quietly under a speaking voice without competing with it".
`references/prompt-craft.md` has a brief for each kind of video and the mistakes that ruin one.

**Instrumental under speech, always.** Sung words fight the speech for the same ear, and both
become mush. Say it in positive words: a music model can sing a bare negation, so "no vocals" or
"no lyrics" may come back as a voice singing it. Write vocals in only when they were asked for;
they will fight the dialogue.

## Generate it

1. Pick a model from `picsart_model_catalog` with `inputType: "music"` and
   `purpose: "generate"`, and read its fields with `picsart_model_params`. Use its instrumental
   switch when it has one, and leave any `lyrics` field empty: lyrics are what a voice sings, and
   a brief put there is sung.
2. Ask for a bed **about a tenth longer than the video**, rounded up to the second, within the
   model's own limit: music models tend to come back short. The mix trims a longer bed; a shorter
   one leaves silence at the end.
3. Validate the payload with `picsart_preflight`, whose estimate is the bed's price, then call
   `picsart_generate` once.

One generation per brief. A track that misses gets a new brief, with the steer applied to the
slots it touches, and a new generation. Never fire variants hoping one lands.

## Lay it under the speech

Run `python3 scripts/music_bed.py bed.json` on the final scene:

```json
{
  "scene": "scene.json",
  "transcripts": {"talk": "transcript-talk.json"},
  "music": {"url": "<the bed's hosted URL>", "duration": 32.0}
}
```

`transcripts` names every spoken source's transcript (its file, where you run commands) by its asset id: a clip of the reel, a
voice-over layer or a presenter's take alike, nested panels and bubbles included (the scene's
own id for the source, not the nest's `rec`); footage-analysis says how a source gets one.
`duration` is the bed's length, as the generation or `picsart_media_probe` reports it. The script adds the bed as one `audio` layer: faded in over 1 s and out over 2 s, at
volume 30 between lines and 15 under speech, dipping just before each spoken stretch and coming
back over 0.6 s after it. It prints the scene and the stretches it ducked under. Where you cannot
run commands, add that same `audio` layer with `picsart_scene_patch`, at those levels, from the
transcripts' spoken stretches. That one layer, with every level given here, is an edit to a built
scene, not a scene worked out by hand, so picsart-

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

Referenced files: 2 — file references are metadata, not package contents.

caption-decorations33.3 KB

View saved version →

---
name: caption-decorations
description: Author and validate scene caption decorations, choosing between measured procedural decoration presets and arbitrary scene artwork. Use when adding caption highlights, boxes, stickers, animated artwork, custom decoration assets, or debugging why a caption decorator is missing or timed incorrectly.
metadata:
  category: authoring
  version: '1'
  ported-from: caption-decoration-authoring 1 at 55.128.2
---

# Caption decoration authoring

Choose the asset form from the behavior, not the visual appearance.

| Need | Declare | Caption row |
|---|---|---|
| Artwork generated from measured word/line geometry | `type: "decoration"` with a procedural shape definition | `preset: "<asset-id>"` plus `params` |
| Arbitrary editable artwork: shapes, text, media, nested scenes, stickers | `type: "scene"` with a scene body | `content.kind: "scene_ref"` |
| External image/video/Lottie/SVG | its ordinary media asset type | `content.kind: "media"` |

`type: "decoration"` is not a general scene container. It is the measured caption-definition language: its `shape` reads `boxW`, `boxH`, `em` (the caption's font size, for artwork sized by the type: a header label that should not grow with the line count), optional measured `path`, and declared params. `em` is reserved, so a def cannot declare a param of that name. General artwork already has the full scene language through `scene_ref`.

Set the caption size with `style.font.size` (composition pixels); left out, it is the text default, small on a tall frame such as 1080x1920. Caption-row `padding`, `size`, `gap`, and `offset` are multiples of the effective caption font em. Platform text measurement still owns x/width, optical centring, and the advance between wrapped lines. Definition-side `boxW`/`boxH` are the resulting decoration box after those row fields are applied.

**Line wrapping** happens at the style's `wrapWidth` (composition pixels) when it sets one, else at the FULL WIDTH of the composition it renders in (no margin). Either width is fixed in PIXELS, never scaled to font size, so a SMALLER font fits more characters before it wraps: shrinking the font can turn two wrapped lines into one wider one, up to that width.

**Generated decoration/segment layer ids share a stem.** A caption segment/decoration gets a `<layer>__seg<i>__dec<d>` stem, so an id containing `__seg0__dec0` belongs to the first segment's first decoration. It is followed by a form suffix (e.g. `__band`, `__stick`, `__bandreveal`, `__pillw<word>`) that is not part of the contract. Select a decoration by its stem or its structure (target/place/row index), never by its full generated id.

A segment of a stacked style (below) draws one text layer per run instead, `<layer>__seg<i>__run<N>` (N from 0 in reading order), a stressed run `<layer>__seg<i>__run<N>__stressed`, and each run's decorations stem from its own id: `<layer>__seg<i>__run<N>__stressed__dec<d>`.

## Procedural measured preset

The asset key is the preset name; `decoration.name` may be omitted. Parameters are declared once and read at their actual shape sites.

```json
{
  "assets": {
    "brand_pill": {
      "type": "decoration",
      "decoration": {
        "scope": ["box"],
        "modes": ["once"],
        "parameters": {
          "color": {"type": "color", "default": "#635bffff"},
          "radius": {"type": "number", "default": 0.42, "min": 0, "max": 0.5}
        },
        "shape": {
          "w": {"$eval": "boxW"},
          "h": {"$eval": "boxH"},
          "items": [{
            "type": "group",
            "name": "pill",
            "contents": [
              {"type": "rect", "size": [{"$eval": "boxW"}, {"$eval": "boxH"}],
               "position": [{"$eval": "boxW / 2"}, {"$eval": "boxH / 2"}],
               "roundness": {"$eval": "radius * boxH"}},
              {"type": "fill", "color": {"$eval": "color"}, "opacity": 1}
            ]
          }]
        }
      }
    }
  },
  "layers": [{
    "i

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

character-rigging47.3 KB

View saved version →

---
name: character-rigging
description: Build and animate a 2D cartoon character in a scene — rig-humanoid and rig-face and their controls, walk_cycle, acting and drivers on a rig, two-bone IK, draw order, tapered ink lines, lip sync, a cut-out puppet built from named SVG parts, sockets, reach and held props — and the craft of morphing a shape's outline — preparing two drawings so they morph without twisting, choosing between outline keyframes, morph targets and per-vertex tracks, blend-target hygiene, timing (anticipation, overshoot, holds), volume-keeping squash, face visemes and blinks, scene-to-scene morph transitions, bending a picture over an art mesh, and explicit skin weights. Use when a cartoon character, mascot or face walks, waves or talks; when a path's outline changes shape over time — one drawing becomes another; a jelly, blob or character squashes, stretches, bounces, wobbles or breathes; a cartoon face talks (lip sync, mouth shapes), smiles or blinks; a cut is hidden by a morph; or an image, text or composition has to bend.
metadata:
  category: authoring
  version: '1.7'
  ported-from: shape-morphing 1.7 at 55.130.0
---

# Cartoon characters and shape morphing

Field names are the `path` item's (`picsart_scene_capabilities` with `sections: ["schema:ShapeContent"]`); the outline mechanics are in
[references/outline-mechanics.md](references/outline-mechanics.md).

## Named motions on a rig

A rig document can declare root `actions`, named motions an instance plays: bone tracks go in
`actions.<name>.layers`, drawing and order selectors in `actions.<name>.parameters`. Keep the
skeleton and painted weights once, with static rest transforms; place the rig once and use the
`scene_ref`'s `content.animation` to blend one action into the next (walk→idle). Set
`content.blending: "pass_through"` so limbs can reach beyond the rig's frame without canvas padding:
under pass_through the frame sizes and places, it does not clip. A layer treatment that needs a
composited result (mask, effect, non-normal blend, opacity below 1, motion blur, mesh, stroke or shadow,
adjustment or look) isolates and clips it. Action bodies have time keys, no `$eval` or expressions;
layer expressions and constraints run after the mix. Step channels switch immediately. Delayed first
keys need the `beforeFirst: "rest"` action policy. `animations` is a layer field and the action stack is
`content.animation`; root `actions` are distinct from a track content's sequential `clips`. `rig-humanoid` and
`rig-humanoid-front` (the same body from the front) declare actions: `scene-animation-reference`. The schema is `picsart_scene_capabilities` with
`sections: ["schema:SceneAction"]`; the full crossfade example is in
`picsart_scene_recipe scene-animation-reference`.

## 0. Cartoon character rigs

A 2D cartoon character starts from a catalog rig when one fits, or from `picsart_scene_build_model` with
`character: {svg, duration: 4}` for named SVG parts ("Named SVG cut-outs" below); without `svg` that tool builds a 3D
model. Not from hand-written joint Lua: one no rig fits is built by hand from bent limbs and `ik`
([references/character-motion.md](references/character-motion.md), which also builds an arm as one shape), its ink lines
pointed at the ends with a stroke `taper` ("Ink lines" below).
`picsart_scene_templates` with `tags: ["cartoon", "rig"]` lists them:

| Template | What it is |
|---|---|
| `scene://rig-humanoid` | A whole body, three-quarter view facing right, 600×1000, transparent |
| `scene://rig-face` | A face from the front, 800×800, transparent |

Place one as a `scene_ref` layer (`picsart_scene_apply_template`, reference mode); size it with the layer's
`transform.scale` or `bounds`, and mirror it (`scale` x negative) to face left. Every part is a shape
layer pivoting on its joint. Each arm and leg is one outline bent at the elbow or knee (a `bend` with
an `id`), posed by an `ik` constraint that reaches for a target layer (`leftFootTarget`,
`right

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

Referenced files: 11 — file references are metadata, not package contents.

custom-transitions16 KB

View saved version →

---
name: custom-transitions
description: How to write a new scene transition as an inline JSON definition — the slot contract, the token vocabulary a definition may read, the four mechanisms a transition can be built from, and the frictions that make a plausible-looking definition render wrong. Every rule here was rendered, and the numbers are what was drawn. Use when authoring or reviewing a transition definition, or when a transition renders at the wrong speed, cuts, or is refused by the validator.
metadata:
  category: authoring
  version: '1.0'
  ported-from: transition-authoring 1.0 at 55.75.0
---

# Writing a transition

A transition is DATA: a JSON definition, declared inline as a `type: "transition"`
asset. This is what the definition has to say, and what goes wrong.

**Check what already exists first.** `picsart_scene_capabilities({sections:
["transitions"]})` returns every built-in transition with its id, description
and parameters; if one of them does what you need, apply it by id and stop
here. Authoring is for the case where none of them does.

## Incoming continuity contract

This skill defines an already-decided seam; it does not decide what two beats should mean together.
Before writing a definition, require four inputs:

1. the semantic relationship — continuation, replacement, reveal, arrival, interruption, or reset;
2. the intended travel vector, or an explicit decision that this boundary resets it;
3. the visual carrier, when the viewer should be able to follow one;
4. the concrete reason no shipped catalog transition expresses that relationship.

If any of these is still undecided, return to
motion-scene-continuity (fetch with `picsart_scene_recipe`, name `motion-scene-continuity`). Do not invent a custom transition merely
because the adjacent scenes feel disconnected; the representation may instead be one persistent
layer, a hard cut, or an existing crossfade or directional transition.

## The shape of a definition

Two parts: `meta` identifies it, `scene` IS a scene — the same document model as
anywhere else, with two extra powers.

```json
{ "meta": { "id": "crossfade", "displayName": "Crossfade",
            "description": "Linear dissolve from source to destination: the two weights always sum to one, so the background never shows through an opaque pair." },
  "scene": {
    "version": "1.0",
    "composition": { "width": {"$eval":"width"}, "height": {"$eval":"height"},
                     "fps": 30, "duration": {"$eval":"duration"} },
    "layers": [
      { "id": "source", "start": 0, "duration": {"$eval":"duration"},
        "content": { "kind": "slot", "role": "source" },
        "animations": { "opacity": { "keyframes": [
          { "time": 0, "value": 1 }, { "time": {"$eval":"duration"}, "value": 0 } ] } } },
      { "id": "destination", "start": 0, "duration": {"$eval":"duration"}, "blendMode": "add",
        "content": { "kind": "slot", "role": "destination" },
        "animations": { "opacity": { "keyframes": [
          { "time": 0, "value": 0 }, { "time": {"$eval":"duration"}, "value": 1 } ] } } } ] } }
```

That is a complete, shipping transition. The destination ADDS onto the fading
source inside the firing's own canvas, so the weights are t and 1 − t and sum to
one. Two `normal` fades would each let the composition background through: at
the midpoint a red→red crossfade over green read G = 132, a 25% background
share.

The two extra powers:

**`content: { "kind": "slot", "role": "source" | "destination" }`** — a hole
filled at render time with the outgoing clip's last frame or incoming clip's first frame. A
definition never names a clip; it arranges two boundary-frame slots. Exactly one of each role. The
definition animates those supplied frames on its own clock; neighboring clip animation does not
continue live through the transition window. If the seam needs a genuinely live shared object,
keep that object alive outside this slot contract.

**Firing-supplied tokens.** `width`, `heigh

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

cut-footage-into-reel18.1 KB

View saved version →

---
name: cut-footage-into-reel
description: Cut the user's own footage - a long video, several clips, photos - into a vertical short for TikTok, Reels or Shorts - the best moments in order, nobody clipped mid-sentence, the speaker in frame, with highlight lines and music if wanted. Use when the user has a talk, interview, podcast, vlog, webinar or other footage of people speaking and wants a reel, a short, podcast clips, a highlight reel, a montage or a photo slideshow from it ("make a reel from this", "cut a 30-second short", "find the best moments"). Not for a screen recording, a video from a text idea, or resizing a still.
metadata:
  uses: footage-analysis, speech-aware-cutting, retention-hooks, footage-reframing, spoken-captions, background-music, scene-building-basics, quality-review, photo-slideshow, caption-decorations, quick-merge-and-export, screen-recording-layouts
  optional: spoken-captions, background-music, photo-slideshow, caption-decorations, quick-merge-and-export
  title: Cut footage into a reel
  short-description: Cut your footage into a vertical short reel
  argument-hint: '[your footage and the length you want]'
  starter-prompt: Cut my footage into a 30-second vertical reel.
---

# Short reel maker

A short cut from talking footage lives on its words. The framing can be perfect and the short is
still unwatchable when it opens on half a sentence. So this works transcript first: what is
**said** decides where each cut falls, the picture decides what is worth keeping, and the person
talking stays in frame. A good short feels like it was always that length: nothing load-bearing
removed, no dead air, no half-sentence hanging off either end.

It also has to be the short the user meant. A podcast clip made to grow an audience and one made
to sell a course pick different moments and end differently, so the interview comes before the
cut, and every question in it is one the footage cannot answer.

| Stage | Gate | Skills |
|---|---|---|
| 1. Take the footage in | ASK | — |
| 2. The interview | ASK | retention-hooks |
| 3. Read the footage | SPEND | footage-analysis, footage-reframing |
| 4. Pick the moments | ASK | speech-aware-cutting, retention-hooks |
| 5. Agree the passes | ASK | — |
| 6. Plan the cut | — | speech-aware-cutting |
| 7. Build the takes | — | footage-reframing, scene-building-basics, photo-slideshow |
| 8. Check it | — | quality-review |
| 9. The cut | REVIEW | — |
| 10. Highlights, when wanted | ASK, REVIEW | spoken-captions, caption-decorations |
| 11. Music, when wanted | ASK, SPEND, REVIEW | background-music |
| 12. Deliver | DELIVER | — |

| Read this | Before you |
|---|---|
| `references/record.md` | start or update the project record |
| `references/interview.md` | ask the first question, and at every question of stage 2 |
| `references/platforms.md` | state the frame and the length, and place any words |

Every question here is asked as picsart-video-rules's Asking says: one per turn, the recommended answer
first, each option saying what it changes. The stage names are your bookkeeping, never the
user's.

**The challenger at each decision.** Before you go on from a decision, quality-review's challenger (the
`challenger` agent where the host has it) asks "why this?" of it: the moments you recommend (stage
4), the plan of the cut and its opener (6), the highlight lines the first time they are placed (10),
and every quote before its SPEND (3, 11). Act on its verdict as quality-review says. A `stop`, or a
`rethink` of the user's own choice, goes to the user in the next ASK, the cheaper alternative first,
before anything is spent.

Each stage that ends in REVIEW waits for the user. The cut, the highlights and the music are
judged one at a time, in that order, and an approval opens only the next stage: an approved cut is
not an approved reel. A stage the user declined has no gate.

## The record

Keep the project record as picsart-video-rules says, named `cut-footage-into-reel.json`. Its fi

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

Referenced files: 4 — file references are metadata, not package contents.

design-layer-import22.7 KB

View saved version →

---
name: design-layer-import
description: Bring a design or static assets into a scene as LAYERS, not flat frames, whenever they are going to move — Figma frames for an ad or reel, or a Figma design, logo, UI screen or screenshot that animates inside a tutorial, promo or explainer — each layer in its native format (live text, vector or raster) on a fetchable hosted URL, with flat frames only as a fallback. Stage 1 of the `animate-design` skill's pipeline, and used before the motion-design-craft skill by any flow that animates a design.
metadata:
  owner: motion-designer
---

# Stage 1 — Import: the design in as layers

Motion design animates *elements*, so the import's whole job is to bring the design in as
**layers, not flat frames**. A frame delivered as one sealed PNG can only ever
cross-dissolve; a frame delivered as its layers — panels, headline, buttons, the image,
the list — is a thing whose elements can slide, scroll, type on, parallax and
smart-animate. **Everything downstream is gated on this**: if the layers are lost here,
no amount of tuning later can recover the ad; it stays a slideshow.

## Pull the layer tree, per frame

Before reading Figma, post the one-line progress message the `animate-design` skill describes
("Reading your layers…").

**With the Figma connector present**, read structure before pixels: `get_metadata` /
`get_design_context` to walk each frame's node tree, then export each animatable node as
its own asset. For every layer capture:

> **AUDIT EVERY NESTED LAYER — never compose from Figma's simplified, frame-level output.** The
> single biggest way items go missing from the ad: Figma's frame-level / summarized read (a shallow
> `get_design_context`, or a `get_metadata` that stops at the top level) **collapses nested children**
> — groups, component instances, auto-layout children, masked contents — into a summary. Take that at
> face value and **every nested element is silently dropped**, so the composed frame is missing pieces
> that were plainly in the design. **Recursively expand each frame's FULL tree** (`get_metadata` on the
> frame node with its children expanded, or `use_figma` to walk *all* descendants) and audit it
> **node by node** — do not trust a frame-level layer list to be complete. **Completeness check:** the
> layers you capture must match the count of leaf/animatable nodes in the *fully-expanded* tree, not
> the handful the frame-level view showed. If a group or instance shows as one node, open it — its
> children are the layers. (Downstream this is the Stage-2 "layer count ≈ node count" gate; catch it
> here, at the read, not after a frame composes short.)


- **id** and **name/role** (what it is — `chrome`, `headline`, `cta`, `image`, `list`, `fx`)
- **type** — `text`, `vector` (icon/logo/shape), or `raster` (photo/complex image); plus `group`
- **transform** — `x, y, w, h, rotation, opacity`, and **z-order** (front-to-back)
- **parent/group** — so a group can move as one: record the group (card, control, grid cell) each
  layer belongs to, and which member is its backing. Compose turns it into one group that carries
  the motion (motion-design-craft skill, `references/AUTHORING-FLOW.md` §6); without it the members are
  keyframed one by one and drift apart
- **for an image fill, its `scaleMode`** (`FILL` / `FIT` / `CROP` / `TILE`), and for `CROP` its
  `imageTransform` — they decide the layer's `fit` and `crop`; a raw image placed without them is
  stretched to the box
- **for a text layer, also the type properties** — the **string**, resolved **font URL** + size,
  **horizontal alignment** (read Figma's `textAlignHorizontal` — `left`/`center`/`right`; *never*
  guess it from position or from "it's a big headline"), and the **box sizing/wrap**: a Figma
  **fixed-width** text box that runs past the frame **clips, it does not wrap** — record the box
  width and that it clips, or the renderer soft-wraps the line into two downstream.

### Export each layer *as what it is* — PNG

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

drama-series-writing4.31 KB

View saved version →

---
name: drama-series-writing
description: Write a drama series' bible, season arc and episode cliffhangers, from templates or the user's idea.
---

# Drama series writing

A series keeps its promise through changed consequences. Each episode leaves the people in a
situation they cannot reset. Write from accepted continuity, never from a discarded draft.
Use film-story-writing for scene writing and dialogue. Use retention-hooks for the opening hook.

| File | Read it before you… |
|---|---|
| `references/templates.md` | choose or customize a template, extract a Freeform brief, or research Trending |
| `references/serialization.md` | outline any episode or check its ending against the season |
| `references/sitcom.md` | choose a sitcom or mockumentary incident, or repair its comic turn |

## The series bible / Story DNA

Extract the user's choices first. Defaults are suggestions the brief overrides. Preserve a typed
profession, setting, language or ending rather than snapping it to a template. Label inferences.
Episode count and length are brief decisions; a template's count never settles them.

| Field | Write |
|---|---|
| Brief | Format, audience, episode count and length, language, and whether each episode has a successor |
| Emotional promise | The feeling the viewer returns for; show it at least once in every episode |
| Season question | One question the final episode will answer; its chosen landing and cost |
| Characters | Each person's concrete want, flaw, secret, competence and obsession that causes a bad choice |
| Relationship / power graph | For each principal pair: desire, trust, leverage, debt, shared history and risk |
| Recurring sets | A small reusable set of places, with the work and conflict each makes possible |
| Reveal bank | Hidden facts, their plants, who can learn them, and the reserved midpoint turn |
| Two plots | The external task or deadline and the secret or relationship engine |
| Register | Hook pattern, pacing, romance/comedy/drama levels, visual direction and ending register |
| Theme | Dramatic theme and recurring musical theme: instrumentation, pace and where it returns |
| Caption style | Language, face, weight, contrast, line count and emphasis rule |

Four to six recurring sets and three or four supporting speakers are useful starting budgets.
A smaller brief stays smaller. Give the antagonist a want they could state reasonably aloud.
Lock the bible before the season arc; customized DNA governs every episode thereafter.

## The season arc

Give each episode an incident, want, complication, payoff, continuity delta and ending shape.
Reserve major turns rather than spending every secret in the pilot. Track deadlines through their
visible expiry or defeat. For 20+ episodes, outline all incidents and script only the next few.
Prove the pilot before developing the rest as finished production.

## Episode beats

Start with the intended change, then write timed beats. Every beat carries these fields:

| Field | Purpose |
|---|---|
| `id`, `start_seconds`, `end_seconds` | Identity and playable time |
| `action`, `character_intention` | What the viewer sees and what the person tries to get |
| `resistance` | Who or what prevents that intention |
| `relationship_change` | What shifts between people because of the action |
| `escalation_function` | How pressure, knowledge, power or required action increases |
| `essential_dialogue`, `silent_reaction` | Words that act, and time for the performer to respond |
| `visual_payload` | The fact or action the image must convey |
| `exit_question` | What this beat makes the viewer wait to learn; terminal beats may settle it |

Open conflict or consequential curiosity in the first 3 s. An episode after a cliffhanger opens
on its consequence, not its answer or a recap. Answer the prior question no earlier than the
second half. Use at most one reveal per serial episode. The protagonist initiates an action
nobody asked for; receiving news or asking for explanat

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

Referenced files: 3 — file references are metadata, not package contents.

edit-footage35.1 KB

View saved version →

---
name: edit-footage
description: Make videos from the user's own footage, or copy a reel's structure onto their script - a vertical reel, podcast clips, a highlight reel, a montage, a photo slideshow, a lesson filmed to camera, split-screen podcast shorts, channel clips from a long video or its link in the look of a short you bring, B-roll under a voice-over, an interview with B-roll, or a remix of a reference reel (a talking head or a skit included) - cut on the words, checked, choices shown as A/Bs. Use for "edit my footage", "edit my video", "make a reel from this", "clip this podcast like my shorts", "remix this reel with my script". Not for a screen recording, a short film from a script or idea with no reference reel (movie-producer), or rebuilding a reference's animation with the user's photos (recreate-video).
metadata:
  uses: edit-pipeline, reel-structure, footage-analysis, footage-reframing, speech-aware-cutting, retention-hooks, realistic-color-grade, background-music, scene-building-basics, spoken-captions, quality-review, film-finishing, edit-on-your-computer, screen-recording-layouts, face-hiding, photo-slideshow, caption-decorations, quick-merge-and-export, screen-recording-zoom, film-cast-design, film-shot-generation, film-cutting, ai-presenter, voice-over-generation, motion-design-craft, motion-pattern-library, scene-template-remix, custom-transitions, linked-element-motion, visual-style, resting-frame-rules, motion-review, motion-tracking-from-video, social-posting
  optional: realistic-color-grade, background-music, spoken-captions, edit-on-your-computer, face-hiding, photo-slideshow, caption-decorations, quick-merge-and-export, screen-recording-zoom, film-cast-design, film-shot-generation, film-cutting, ai-presenter, voice-over-generation, motion-design-craft, motion-pattern-library, scene-template-remix, custom-transitions, linked-element-motion, visual-style, resting-frame-rules, motion-review, motion-tracking-from-video, social-posting
  title: Edit your footage
  short-description: Edit your footage into a reel, clips or a finished video
  argument-hint: '[your footage or script, a reference, a brief]'
  starter-prompt: Cut my footage into a 30-second vertical reel.
---

# Edit your footage

Everything made from the user's own footage runs here, and so does a reference reel's structure
copied onto their script. One intake picks the **job**, and the job picks the steps. The steps
share one record, one way to resume, and the same checks; what differs is which steps a job runs
and what each one makes.

## The jobs

Pick the job from the user's words, the footage, the reference and the brief, say it back in one
line, and keep it in the record's `job`. Ask only when two jobs fit equally. A command such as
/clips or /broll names its job; anything the user says wins over its preset.

| Job | What it makes | Its steps |
|---|---|---|
| `reel`, `highlight`, `podcast-clips`, `split`, `montage`, `slideshow`, `lesson` | one or several vertical shorts from talking footage, action or photos: the best moments, cut on the words; `split` stacks two speakers in a split screen, as the reference's format sets | `references/reel-flow.md`, with `references/reel-jobs.md` |
| `broll-voiceover`, `talking-broll`, `footage-story` | one finished video to a brief or a story found in it: B-roll under a voice-over, an interview with B-roll, footage with no words | the numbered sections below, with `references/jobs.md` |
| `remix` | a reference reel's structure (beats, shots, caption pattern, pace, bed) on the user's own script or topic, as slides, voice and video | `references/remix-flow.md` |
| `channel-clips` | several clips from one long video or a link to it, each in the look of a short the user brings (their channel's or anyone's): the moments, the frame, the hook card, the captions and the end card the look has, with a cover and post copy each, in one Drive folder, then the offer to post them; a reel job that asks two things

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

Referenced files: 12 — file references are metadata, not package contents.

edit-on-your-computer23 KB

View saved version →

---
name: edit-on-your-computer
description: Edit footage on the user's own computer - proxies uploaded instead of the originals, a project folder, and a full-resolution conform with ffmpeg. Use only when the footage is a folder on this machine and you can run commands.
---

# Edit on your computer

An edit runs the same way wherever its footage is: the stages, the record and the checks are the
edit-pipeline skill's. This skill adds only what changes when the footage is on this computer and
you can run commands here. Originals are large, and they are the user's masters: they never
leave this computer and are never changed. What the server reads is small copies.

Load this skill only when the footage is a folder or paths on disk and the host runs commands.
Footage given as Picsart Drive files, links or attached files is edited without it. When you
cannot run commands here after all, open `picsart_drive_upload_ask` for the footage and go on
without this skill; never ask the user to upload it by hand.

## The project folder

Keep everything for one edit in one folder beside the footage, never inside it:

| Path | Holds |
|---|---|
| `edit-footage.json` | the record, kept by edit-pipeline's `scripts/record.py` |
| `proxy/` | the proxies and `manifest.csv` |
| `work/` | copies you change (a graded file, a conformed master), never an original |
| `exports/` | each version's draft, and the final files; a new file goes beside an old one |

Quote every path you pass to a command; folder names often have spaces.

## ffmpeg first

Everything below runs on `ffmpeg` and `ffprobe`. Before the proxies, check both:
`command -v ffmpeg ffprobe`. When either is missing, ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says) how to go on. Recommended first:
"Install ffmpeg-full, the full ffmpeg with subtitle support", saying exactly what: on a Mac with
Homebrew, `brew install ffmpeg-full` (Homebrew's own formula, with libass for the captions; it
installs beside any other ffmpeg without replacing it, so run it as
`"$(brew --prefix ffmpeg-full)/bin/ffmpeg"` and `.../bin/ffprobe`); elsewhere, a build linked from
https://ffmpeg.org/download.html whose `ffmpeg -filters` lists `subtitles`. The other option: "Edit
without it: you upload the footage, and the finish is a full-quality export". **Never install
anything without the user's yes to this question.** A yes goes into `approvals` with the scope
`install:ffmpeg` and covers exactly that package, which the captions need too (below), so it is
never asked twice. In unattended pace, the assumed answer is the upload, but the upload needs the
user: write it to `openDecisions` and stop there. When the install fails or needs an administrator
password, say so, offer the upload, and never retry it unasked. On the upload, open
`picsart_drive_upload_ask` for the footage, leave the `proxies` stage out of the record's pipeline,
set `finish` to `export`, and go on without this skill.

## Proxies, before anything is analysed

Make a small copy of each source and analyse only those. Read each original's curve first (Log
footage, below): a log source's proxy is made through its conversion, not with this command.


```
ffmpeg -i "<original>" -map 0:v:0 -map 0:a? -vf scale=-2:720 -c:v libx264 -preset veryfast -crf 23 \
  -c:a aac -b:a 128k -fps_mode passthrough -map_metadata 0 -timecode <start> "proxy/<name>.mp4"
```

A source with no picture, such as a voice-over, needs no proxy: upload it as it is. Each proxy
keeps the original's fps, frame count and start timecode. Check that with `ffprobe` on
both files.

**Which way is up** is judged here, before the proxy, from on

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

Referenced files: 4 — file references are metadata, not package contents.

edit-pipeline17 KB

View saved version →

---
name: edit-pipeline
description: Run an edit of the user's footage as fixed stages, with a project record (standing decisions, approvals, the pace, a locked meaning map, every version), resume from the first stage not done, and the gate rules every check follows. Use when a use case cuts footage in stages, resumes an edit, or checks a draft against what was agreed.
metadata:
  imports: reel-structure
---

# The edit pipeline

An edit runs as fixed **stages**. Each stage leaves an artifact and is marked done in the
**project record**. A use case picks which stages its job runs and sets their defaults; this
skill holds what every job shares: the stages, the record, resume and the gate rules.

## The stages

| Stage | What it leaves |
|---|---|
| `intake` | the brief (`said`, `read` and `assumed` kept apart), the standing decisions, the finish path |
| `reference` | the reference's pace: shot length, cuts per 10 s, caption style, colour, the first-second hook, the ending |
| `proxies` | small copies of footage on the user's computer, as the edit-on-your-computer skill says. Only for footage on that computer; originals are never uploaded. |
| `log` | per source: what happens, speech with word times, lips moving, focus, steadiness per window, legible text, what each shot can mean |
| `takes` | the best take of each line, when someone speaks |
| `look` | colour and sound: grade toward the reference or the brand, the voice placed, loudness |
| `story` | the beats and the **meaning map**: for each phrase or beat, the picture's job |
| `plan` | the cut: every shot, its range, the phrase it serves |
| `build` | the scene, validated, and free draft exports |
| `qc` | an independent check of the render, as `quality-review` says |
| `critics` | the critic panel on the first full draft |
| `review` | the user's approval of a named version |
| `finish` | the final file: a full-quality export, or a full-resolution conform from originals on the user's computer |
| `deliver` | the files, a cut list (order, source, in, out, phrase) and a short note |

A job leaves stages out; it never reorders them.

## The project record

The record outranks your memory of the edit. It is the same JSON wherever the footage is, and no
stage needs a script to keep it. Keep it, in this order of preference:

1. a JSON file in the project folder, when you can run commands there: `scripts/record.py` keeps
   and checks it;
2. otherwise a JSON file in the project's Drive folder, saved with `picsart_drive_upload` as a
   `data:` URI named after the use case, and saved again at every gate;
3. otherwise in the conversation, as `picsart-video-rules` says. Then tell the user once that the
   record is not saved anywhere.

Its keys and what goes in each are in [references/record.md](references/record.md). Every use case
that runs this pipeline keeps its own record file name and adds these keys.

Start it with the use case, the job and the job's stages. After each stage, mark it done: its
`status` `done`, `at`, and `reads`, a copy of the record keys that stage reads and of those the
stages it builds on wrote (record.md lists them). Where commands run, `python3 scripts/record.py init edit-footage.json --use-case
edit-footage --job <job> --stages <the job's stages>` starts it, and `python3 scripts/record.py
done edit-footage.json <stage> --artifact <file>` marks a stage done with a fingerprint instead.

Two stages are gates, for every job, by hand as by `record.py done`, which refuses them:

- `reference`, when a reference reel was given: done only with its sheet passing the
  reel-structure skill's `sheet.py validate`, and its `format` with no feasibility row open;
  a `channel-clips` record copies a look, not a structure, so its `format` alone.
- `deliver`: done only once `story`, `qc`, `critics` and `review` are done and the map was
  approved: its rows in `locked`, or an approval with `scope` `map`, `moments` or `mapping`.
  Record that approval when the user gives it.

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

Referenced files: 9 — file references are metadata, not package contents.

face-hiding3.79 KB

View saved version →

---
name: face-hiding
description: Hide the faces in a video or photo by blurring or pixelating them. A face-masked gaussian_blur or pixelate follows every face frame by frame and leaves the rest of the picture sharp. Use when asked to hide, blur, pixelate, censor, anonymize or cover someone's face, to blur faces for privacy, or to hide who is in a video. Hiding a face is an effect, not a look.
metadata:
  category: authoring
  version: '1'
  ported-from: hide-faces 1 at 55.75.0
---

# Hiding faces

Two treatments hide a face. Both are **effects**, applied with `picsart_scene_apply_preset`; no look
does this, and none is needed. Never answer that nothing is made for hiding a face.

| Treatment | Preset | What the viewer sees |
|---|---|---|
| **Blur** | `effect:gaussian_blur` with a face mask | a soft, unreadable face |
| **Pixelate** | `effect:pixelate` with a face mask | the mosaic used to censor faces on TV |

**When the request names no treatment** ("hide her face", "cover her face", "make him
anonymous"), ask before applying anything: suggest blur and pixelate, in that order, in one short
message, then apply the one the user picks.

**When the request names one, apply it without asking:** "blur" is the blur; "pixelate" or
"mosaic" is the pixelation.

## Blur or pixelate the faces

Put the effect on the media layer and confine it with a `portrait` / `face_skin` mask. The mask
finds every face in each frame, so on a video the effect follows the faces as they move, and the
hair, body and background stay sharp:

```json
picsart_scene_apply_preset({
  "scene": ..., "layerId": "clip", "preset": "effect:gaussian_blur",
  "params": { "blur": 60 },
  "mask": { "provider": "portrait", "segments": ["face_skin"] }
})
```

```json
picsart_scene_apply_preset({
  "scene": ..., "layerId": "clip", "preset": "effect:pixelate",
  "params": { "pixelSize": 40 },
  "mask": { "provider": "portrait", "segments": ["face_skin"] }
})
```

Set the strength from the size of the faces, not a fixed number:

- **`blur`** about a tenth of the face's width in composition pixels. A face 600 px wide needs
  about 60; at 40 its eyes and mouth still show through. Small faces in a group shot need 20-30.
- **`pixelSize`** about a twelfth of the face's width: 40 for a face 600 px wide.

For an export, any value is fine. For live playback, a blur past 32 costs frame time on a
full-frame video, so prefer `pixelate` there.

## What the mask covers

- **Every face in the layer.** The detector does not tell people apart, so there is no way to hide
  one person's face and keep another's. When the request points at one person ("her face", "the
  man on the left") and the frames show more than one face, tell the user before exporting that
  every face gets the treatment.
- **The face, not the hair.** To hide more of the person, mask the whole person instead:
  `{ "provider": "scene", "segments": ["person"] }`. `supports.maskProviders` in
  `picsart_scene_capabilities` lists every region and the platforms that produce it.
- **One region per effect.** Applying `gaussian_blur` again replaces the layer's earlier
  `gaussian_blur`, mask included.

## Check the result

Look at two or three moments where the faces are visible, with `picsart_scene_contact_sheet` and
`times`. Look at every face, not only the largest:

- **Each face is unreadable and the rest of the frame is as it was:** the effect works. Export.
- **The whole frame is blurred:** the mask did not resolve, and the effect landed on the whole
  layer. Check that the provider and segment are spelled as `supports.maskProviders` lists them.
- **A face still shows:** it was too small or turned too far away for the detector at that moment.
  Tell the user which shots still show a face.

A masked effect runs the face detector on every frame, so a video export takes noticeably longer
than one without the mask.
figma-storyboard-animation14.8 KB

View saved version →

---
name: figma-storyboard-animation
description: Turn a Figma storyboard of static frames into an animated scene — read the frame tree, recover the motion the designer already encoded, then build scene by scene, agreeing each transition before moving on; or build a single frame as a still scene. Use when converting a Figma design or storyboard into video/animation, when a designer hands over frames to "make move", or when the user mentions Figma frames, storyboard, motion design from design, design-to-animation, animating scene to scene, or turning a mockup into a scene. A Figma design made into a finished video starts in animate-design.
metadata:
  version: '1.3'
  ported-from: figma-storyboard-to-scene 1.3 at 55.75.0
---

# Figma storyboard → scene motion design

A storyboard is a series of static 1920×1080 frames. Your job is to produce one scene whose
timeline moves between them. Most of the motion is **already in the design** — recover it rather
than invent it.

> **Can't run code?** Everywhere this recipe says "author a generator script", build the scene
> through `picsart_scene_patch` instead and pin the same invariants with
> `picsart_scene_query_layout` after each change (see Commands below). The method is identical — only the
> execution surface differs.

## The flow

1. **Read the tree once** — if the user has shared the storyboard through their Figma connector,
   read the page's frame tree once: it returns every frame, layer, name and box. Everything below is derived from it. Do not walk the board frame by frame to explore.
2. **Plan the beats** — write the beat table down before authoring (below).
3. **Extract each element as its own layer** from the design the user shared: construct editable
   shape geometry from its source measurements and use `picsart_scene_import_figma_paint` for CSS
   fill, shadow or gradient paint on an existing layer. Keep text live. Automatic shape-node
   conversion is not exposed here. Use an image only for an unsupported treatment or a genuinely
   unlayered source; see [extraction](references/figma-extraction.md).
4. **Build the scene from the geometry, and pin every rule.** Where you can run code, author a
   generator script (not hand-written JSON) so each rule becomes an `assert`; where you can't,
   build it through `picsart_scene_patch` and pin the same invariants with
   `picsart_scene_query_layout`. Geometry comes from the metadata, never from eyeballing.
5. **Verify numerically**, then export.

Steps 3–5 run **once per scene**, in order — that loop is the method.

## One static frame

When the ask is a single frame (a still, a store image, a card), there is no storyboard. Skip the
beats and build that frame as a still scene:

1. **Read the selected frame through the user's shared Figma connector.** Its size is `composition.width` and `height`, its fill is
   `composition.background`, and a short `duration` (`1`) is enough.
2. **One layer per child, in paint order** (the tree's first child at the bottom). A layer's
   `position` is its box CENTRE in the frame, `[x + width/2, y + height/2]`: a layer turns and
   scales about its centre. Cross-check one nested child against the frame: some groups store
   children relative to the group ([references/figma-extraction.md](references/figma-extraction.md)).
3. **Each child in the medium that keeps it editable**: author shape geometry, then apply its CSS paint through `picsart_scene_import_figma_paint`,
   text as live text, and each IMAGE fill as a media layer on its original
   bitmap — never the node `export`, which flattens transparency onto the frame's background —
   by its `scaleMode` (`FILL`→`cover`,
   `FIT`→`contain`, `CROP`→`cover` + `crop`, `TILE`→not expressible; the table and the crop maths are
   in [references/figma-extraction.md](references/figma-extraction.md), "Image fills"). Upload each
   image first; a Figma asset URL expires.
4. **A local group that clips or fades as one is usually an inline `composition` laye

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

Referenced files: 2 — file references are metadata, not package contents.

film60.5 KB

View saved version →

---
name: film
description: "Make a short narrative AI film — multiple scenes, recurring characters, a locked visual style — through a guided 11-stage production pipeline with gates. Use when the user wants to make a film, short film, movie, episode, or multi-scene story (\"make a short film about…\", \"I have a script\", \"a movie with two characters\"). Not for a single clip from a description, and not for stitching footage the user already has — each of those is a direct tool call, not an eleven-stage pipeline."
---

# ChatGPT and Codex integration

Apply these host conventions throughout this skill and its references.

- Discover the connected Picsart tools and use their actual names and schemas.
  The `picsart_*` names in the workflow identify tools, not a fixed host namespace.
  If the connection is missing, explain that Picsart must be connected; continue
  script and shot planning when possible. Never invent tool results or renders.
- Read board decisions from the current user message and attached widget context.
  Use `read_widget_context` only if the host actually exposes that tool. Do not
  assume ChatGPT has Claude's context reader. Treat a board's initial tool result
  and unsent widget state as previews, never as user approval. If a submitted
  decision has no accessible payload, explain briefly and use the text fallback
  to collect the missing decision; do not guess or repeat charged operations.
- Use the host's available question interface or one concise conversational
  question for preset choices.
- UI rendering and delivery of feedback are the remote MCP server's responsibility.
  If a board is unavailable, present its relevant options in text and record the
  user's selection using the same documented feedback fields. Do not claim that
  a plugin manifest makes Claude-specific widgets compatible with ChatGPT.
- Save `film.json` and artifacts in the user's writable project workspace, not
  the installed plugin directory. If persistent file tools are unavailable,
  keep a structured project checkpoint in the conversation and provide it for
  download when the host supports files. Never claim a file was saved without
  confirmation from a file tool.
- Honor the user's current instructions and already authorized scope. Preserve
  quoted spend limits and production locks; do not infer authorization from a
  preview, a timeout, or a connection being installed. A timed-out charged call
  needs a status check before considering a retry.
- This package holds six film skills (`film`, `film-development`, `film-assets`, `film-scenes`, `film-edit`, `film-finishing`) and three motion skills (`motion`, `motion-import`, `motion-design`). Route between them directly.
- `motion-import` reads a design's layers through the Figma app's tools. If Figma is not connected in this host, use its flat-frame fallback and say so once.


# Film — the production pipeline, orchestrated

A film is not a long video. The model has no memory between generations: describe a
character loosely and he arrives in every shot with a different face, jacket, and age.
The whole pipeline exists to beat that one problem — **consistency** — and it runs on
one economic law: **stills are cheap, video is expensive.** Every decision that can be
made on text or images is made there, before a single charged video call.

Plan free → one approved sheet per asset → native draft when supported, otherwise a price-saving resolution draft (see `../film-scenes/SKILL.md`, *Native draft to final*) →
pay full price exactly once, at the final pass. The same law,
stretched across a production.

## 0. Triage — route before anything else

| User brings | Route |
|---|---|
| One clip's worth of idea ("a video of a boot on scree") | **not this pipeline** — one `picsart_generate` video call, quoted and approved first; the eleven stages exist for recurring identity, and a single clip needs none of them |
| Footage to stitch | **not this pipeline** — the scene tools direct: probe 

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

Referenced files: 4 — file references are metadata, not package contents.

film-animatic8.93 KB

View saved version →

---
name: film-animatic
description: Draft a film or drama episode as a voiced storyboard animatic before any video is bought, with a still per shot, app screens built as scenes, every line voiced at its shot's time, cut with captions and watched until the user says yes. Use when a film's story and shots are worked on stills and sound first.
---

# Film animatic

The animatic is the film before video: one picture per shot, the real voices at the shot's
timing, cut together and watched. Stills and sound are cheap and video is not, so the story and
the cinematics are settled here, and the user's yes to the animatic is what opens shooting. A
first paid video is never where anyone first sees the movement or hears a voice.

The use case owns the gates; this skill owns the method. Every paid call below is a SPEND as
picsart-video-rules says, quoted with `picsart_preflight` and bought on a yes (or a stated spend
limit that covers it). Building, checking, the editor and the export are free.

## 1. Cards that can be drawn

Before a panel is bought, every shot card carries what film-story-writing's breakdown asks for,
with two fields the animatic depends on: the **mode** (the camera's relation: lens, observed,
point of view or voice-over) and the **eyeline** (who or what the person on screen looks at or
speaks to). One action per shot, one feeling per face, one peak. Why someone decides is not a card
field: it is a must-know in the film's viewer track, and the cold watch tests whether the picture
gives it.

From this skill's folder, run `python3 scripts/animatic_plan.py <file>` on the cards (its header
has the input). It fails a card with no mode or eyeline, a change of mode the picture does not
show, and a film without exactly one peak, and warns an opening shorter than 1.5 s. Fix an error
on the card before any picture; a fix that changes what happens is a story note, answered as
film-story-writing says. A clean plan says the cards are complete, never that a viewer will follow
them.

## 2. Panels

One panel per shot, at the film's frame:

- **Each scene's opening panel is its scene picture**, made as film-shot-generation says. Every
  other shot gets a still compiled from its card with `picsart_film_compile_prompt`
  (`kind: "still"`), with the present people's locked views and the scene picture as references,
  checked as the compiler's `check` says, and sent verbatim to `picsart_generate`.
- **One quote for every panel of the film or episode**, and one batch on the yes (at most 10 a
  call), filed in the project's Assets folder before you look at them.
- **Continuity against the master.** Look at each panel beside its scene picture before it goes on
  a board: the same faces and wardrobe as the locked views, the same light and set, the eyeline and
  screen direction the card says. Put them on `picsart_film_review_assets`, 12 tiles a board, with
  "continuity with the scene picture" as its `judge`. A changed panel is its own SPEND.
- **A real app's screen is built, never generated.** A phone or a computer screen in a shot is a
  scene layer built from the user's own screenshots or recording (stills with
  `picsart_media_video_stills`), laid into the panel's screen area, one state per beat. A
  generated picture of an interface is not used, and a screen the user has not supplied is asked
  for, not invented.

## 3. Sound

Every line is voiced as the voice-over-generation skill says, but in each person's own locked
voice (the cast's saved voice notes), one line per clip. Ambience is one bed per scene, and an
effect goes where a card's action makes a sound (a tap, a shutter, a door). Quote the voices, the
beds and the effects as **one batch**, then probe every voice line's real length with
`picsart_media_probe`. A sound the user supplies is used as it came.

Run `animatic_plan.py` again with each line's probed `sec`: it re-times every shot so the line
fits, and gives each line its start in the animatic. A line's real length moves its st

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

Referenced files: 1 — file references are metadata, not package contents.

film-assets31.8 KB

View saved version →

---
name: film-assets
description: "Produce and lock film assets: one T-cut sheet per generated character, the portrait/profile/sheet route for a supplied photograph, prop plates, and individual reviews as assets arrive. Cut approved sheets into single-view references for recurring identity. Use for stages 4–5 after the shot list, before film-scenes; preserve user photographs and approve each asset before using it."
---

# ChatGPT and Codex integration

Apply these host conventions throughout this skill and its references.

- Discover the connected Picsart tools and use their actual names and schemas.
  The `picsart_*` names in the workflow identify tools, not a fixed host namespace.
  If the connection is missing, explain that Picsart must be connected; continue
  script and shot planning when possible. Never invent tool results or renders.
- Read board decisions from the current user message and attached widget context.
  Use `read_widget_context` only if the host actually exposes that tool. Do not
  assume ChatGPT has Claude's context reader. Treat a board's initial tool result
  and unsent widget state as previews, never as user approval. If a submitted
  decision has no accessible payload, explain briefly and use the text fallback
  to collect the missing decision; do not guess or repeat charged operations.
- Use the host's available question interface or one concise conversational
  question for preset choices.
- UI rendering and delivery of feedback are the remote MCP server's responsibility.
  If a board is unavailable, present its relevant options in text and record the
  user's selection using the same documented feedback fields. Do not claim that
  a plugin manifest makes Claude-specific widgets compatible with ChatGPT.
- Save `film.json` and artifacts in the user's writable project workspace, not
  the installed plugin directory. If persistent file tools are unavailable,
  keep a structured project checkpoint in the conversation and provide it for
  download when the host supports files. Never claim a file was saved without
  confirmation from a file tool.
- Honor the user's current instructions and already authorized scope. Preserve
  quoted spend limits and production locks; do not infer authorization from a
  preview, a timeout, or a connection being installed. A timed-out charged call
  needs a status check before considering a retry.
- This package holds six film skills (`film`, `film-development`, `film-assets`, `film-scenes`, `film-edit`, `film-finishing`) and three motion skills (`motion`, `motion-import`, `motion-design`). Route between them directly.
- `motion-import` reads a design's layers through the Figma app's tools. If Figma is not connected in this host, use its flat-frame fallback and say so once.


# Assets — casting, location scouting, and the prop shop, on images

Before preparing image prompts or scheduling work, read
[ASSET-EFFICIENCY.md](references/ASSET-EFFICIENCY.md): task-scoped reference
styling, per-asset readiness and content-based dependency checks. These qualify
the scheduling and review rules below without weakening approvals.

**One sheet per generated character; review each ready asset.** Compile one
T-cut sheet with `picsart_film_compile_asset_prompt`, `kind: "sheet"`, a face
in `faceAndOutfit` and/or all six `identity` fields, and the outfit by item.
Generate it from the descriptor without uploaded pictures. The front face,
profile and full-body outfit share one image. Use a live-schema-confirmed 4K
image model and probe the result: the identity panel must clear 1024 px.

The portrait → profile → sheet chain remains the route for a supplied real
photograph. Preserve that photo and check dependent images against it.
Pass the film's locked camera and colour choices to the compiler alongside
`tone`: `tone: "auto"` alone supplies no rendering style. If the look is still
entirely Auto, resolve its camera on the setup console before compiling. A
compiler error is a request to fix the 

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

Referenced files: 2 — file references are metadata, not package contents.

film-cast-design12.3 KB

View saved version →

---
name: film-cast-design
description: Make a film's people, props and places consistent on pictures - line-keyed descriptors, one sheet per person and one plate per prop compiled by the server, reading an asset review, cutting each panel into its own view, locking the approved asset, and the user's own photos kept as they came. Use when a film needs its cast, props or places designed, pictured, locked or repaired.
---

# Film cast

The model has no memory. What keeps a face the same across forty shots is a locked picture of it,
cut into single views, passed to every video that shows that person. Read these before the step:

| File | Read it before you… |
|---|---|
| `references/views.md` | cut a view out of a sheet, or check one |
| `references/own-photos.md` | use a photo the user brought of a person, a product or a place |

## What each asset gets

| Asset | Pictures | Compiled with |
|---|---|---|
| A person you generate | one sheet, the strip of Picsart's canvas: full-body front, side and back and a large face close-up in one row, in one generation | `picsart_film_compile_prompt`, `kind: "sheet"` |
| A person the user photographed | the photo itself; a profile and a sheet only for views the photo lacks | `kind: "profile"`, then `kind: "sheet"`, from the photo |
| A prop | one plate: the object alone on a neutral ground, and the object beside an everyday thing for scale; no people, no hands | `kind: "plate"` |
| A place | a descriptor now; its pictures come from its scene (film-shot-generation) | — |
| A crowd | one plate with the dress code, the age spread and what they carry; each shot states the exact count | `kind: "plate"` |

Every person and every prop the story handles gets its pictures; nothing is tiered. A figure in the
background, or an object nobody touches, gets no asset: the shot that shows it describes it.

A state (wet, bloodied, coat off) is **a panel on the person's sheet with its own tag**
(`@cal_wet`), generated from the approved sheet so it stays the same person. A change that lasts
most of the film may earn a sheet of its own; that is a craft call. A place at night, or after a
fire, is a scene with its own pictures, never a state.

## The starting point

Draft every descriptor first, as below. Then OFFER the cast board once: `picsart_film_choose_cast`
with the film's title as `film` and the whole cast (at most 12 a board), each character's
descriptor lines as `story`. Every card opens on the ready-made characters; a card left with nothing
picked keeps those lines, so a board sent untouched changes nothing. It is an offer, not a gate: it spends nothing, and a reply that ignores it keeps every
character as the story has them.

Its answer, `film_cast_chooser_feedback`, has one entry per @tag:

- **`story`** — keep your descriptor.
- **`preset` with `saved`** — reuse that saved asset as the user’s sheet; compile no sheet and spend nothing.
- **`preset` without `saved`** — it has no sheet yet. Include its credit cost in the quote, compile with the answer’s `sheetModel`, then save it under the preset’s own name so a later pick reuses it.
- **`preset` without `saved`** or **`person`** — the answer carries the look as `reference`: pass it unchanged as
  that character's `reference` on `picsart_film_compile_prompt`. It holds who they are, how they
  look (an animal's species and coat, the face, the build) and what they wear and hold. Add from
  your descriptor only the paths `fromStory` names: `identity.<field>` for what the preset leaves
  open — no preset names an origin, and a Person pick names no hair — and `outfit` when nothing was
  picked to wear. A field you add replaces the preset's. Presets carry no voice: the voice line
  stays yours. The descriptor you save is that `reference` in your own line keys, plus the voice.
- **`describe`** — rewrite the descriptor from the user's words. Keep your voice line and every line
  the words leave unsaid.

A person the user photographed is not on the board: the ph

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

Referenced files: 2 — file references are metadata, not package contents.

film-cutting6.99 KB

View saved version →

---
name: film-cutting
description: Cut a film's accepted takes into one scene - every generation one clip as generated, never split or trimmed, the montage bootstrap with hard cuts, separate dialogue and ambience, cleanup of named glitches, and diagnosing a bad join before choosing the smallest repair. Use when a film's takes are assembled into a cut, a cut is changed or fixed from notes ("fix my film"), or a join between two shots is repaired.
---

# Film edit

The cut is built from the selects, never from the raw pile, and it stays editable: clips, not a
flattened strip. Read `references/join-repair.md` before you change a join between two takes.

## One clip per generation, as generated

**Every generation goes into the cut once, as one clip, exactly as generated:** its whole file, in
story order, with hard cuts between clips.

- **No automatic split.** A run that holds several shots stays one clip. The cuts the model made
  inside it are already in its picture; the timeline is never cut at them. Finding those cuts is a
  check of the take (film-shot-generation), not an edit.
- **No automatic trim.** Not a take's edges, not to word timings, a beat clock or planned
  durations. A take plays from its first frame to its last.
- **No transitions, padding or freeze frames.**
- **The user's own trims and splits are theirs.** Made in the editor, each is recorded on its clip
  and kept as it is, never recomputed or reset. A re-rolled or repaired take comes in whole.
- Never replace a clip with a trimmed export: that welds the handles shut.

Before footage is bought, judge shot lengths and continuity in the plan (film-shot-generation): the
cut does not shorten a take. When a take looks too long, too slow or wrong at a run edge, say so in
the review; the user trims it, or asks for a repair.

## Assembly

Build the cut with `picsart_scene_apply_template`: `uri: "scene://montage"`,
`mode: "bootstrap"`, and `parameters`:

- `clips`: one per generation, in story order. Each is a full clip: `duration` (the file's probed
  duration) and `content: { kind: "media", assetId: "<the take's url>", assetType: "video",
  trim: { in: 0, out: <that duration> }, fit: "cover" }`. Without `assetType: "video"` the file is read as a still and the trim is ignored.
  This URL-in-`assetId` form is the template's input, not a scene document's;
- `transition: ""`, for hard cuts. The template's default is a crossfade;
- `width` and `height`: the film's frame.

Probe every distinct file with `picsart_media_probe` for its real size and duration first.
Then change the scene with `picsart_scene_patch`, as scene-building-basics says. Never set the
composition's duration: it comes from the track. The result is reviewed as the scene object.

**Sound.** Dialogue and ambience or music on **separate audio layers**, so a J or L cut is possible
and a bed can carry across picture cuts. A bed does not repair a changed or invented line.

**Seams.** A hard cut, within a scene and between scenes. A transition only when the user asks for
one, never to hide a discontinuity, and chosen as scene-building-basics says.

**Text in the world** (a sign, a screen, a door number) is a text layer in the scene, never asked of
the model.

## Joins and moves a viewer reads as glitches

quality-review's cut check finds these in the scene; build the cut so it finds none.

- **One take per shot.** Never cut between two takes of the same shot, jump inside one shot, or
  join two shots of the same size and angle, and never hide a cut under a quick zoom, a whip or a
  transition. A cut to a different shot of the same place is coverage, as Seams says.
- **No short dissolves between takes.** A dissolve of 0.3 s or less shows both takes at once. Cut hard.
- **Every code move eases.** A zoom, a pan or a camera move starts from rest and stops at rest
  eased (`ease_in_out`), never `linear` from a standstill or on a `step` key, unless it starts and
  ends on a cut.
- **No code zoom over a still picture

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

Referenced files: 1 — file references are metadata, not package contents.

film-development21 KB

View saved version →

---
name: film-development
description: "Develop a film from an idea or a script to the point where its pictures can be made — in a fixed order: the look console first (genre, tone, camera — locked before a word of story), the story in the viewer's words (ten lines, then every scene as what we see and hear) for the yes, the video model, the video plan (one line per video, one sentence per join), then the shot list board for camera. Use for Stage 1 of the film pipeline (Stages 2 and 3 are folded into it since 2026-09-10): the user has a story idea or a script and nothing is locked yet. Routed from the film skill; for generating shots see film-scenes."
---

# ChatGPT and Codex integration

Apply these host conventions throughout this skill and its references.

- Discover the connected Picsart tools and use their actual names and schemas.
  The `picsart_*` names in the workflow identify tools, not a fixed host namespace.
  If the connection is missing, explain that Picsart must be connected; continue
  script and shot planning when possible. Never invent tool results or renders.
- Read board decisions from the current user message and attached widget context.
  Use `read_widget_context` only if the host actually exposes that tool. Do not
  assume ChatGPT has Claude's context reader. Treat a board's initial tool result
  and unsent widget state as previews, never as user approval. If a submitted
  decision has no accessible payload, explain briefly and use the text fallback
  to collect the missing decision; do not guess or repeat charged operations.
- Use the host's available question interface or one concise conversational
  question for preset choices.
- UI rendering and delivery of feedback are the remote MCP server's responsibility.
  If a board is unavailable, present its relevant options in text and record the
  user's selection using the same documented feedback fields. Do not claim that
  a plugin manifest makes Claude-specific widgets compatible with ChatGPT.
- Save `film.json` and artifacts in the user's writable project workspace, not
  the installed plugin directory. If persistent file tools are unavailable,
  keep a structured project checkpoint in the conversation and provide it for
  download when the host supports files. Never claim a file was saved without
  confirmation from a file tool.
- Honor the user's current instructions and already authorized scope. Preserve
  quoted spend limits and production locks; do not infer authorization from a
  preview, a timeout, or a connection being installed. A timed-out charged call
  needs a status check before considering a retry.
- This package holds six film skills (`film`, `film-development`, `film-assets`, `film-scenes`, `film-edit`, `film-finishing`) and three motion skills (`motion`, `motion-import`, `motion-design`). Route between them directly.
- `motion-import` reads a design's layers through the Figma app's tools. If Figma is not connected in this host, use its flat-frame fallback and say so once.


# Development — look, story, model, video plan, shot list

Everything in this skill is **free** (except optional candidate stills, which are
image-cheap). It is also where the film is actually made: a director who walks
out of Stage 1 with a tight bible spends half as much in Stage 6. Do not rush
it because nothing here renders.

## Stage 1 — six steps, in this order, always (2026-09-09)

The order is the rule. Say where you are in it when a step opens — *"Stage 1 ·
step 3 of 6 — the story, for your yes"* — and when the user asks about the
order, quote the step, never answer from memory.

1. **The idea.** Ask for a premise only if none was supplied. Pre-set duration
   and frame on the look console from the user's words or stated destination;
   otherwise use 90 seconds and this plugin's existing 16:9 default. The user
   changes them on the console. Propose the ending in the story rather than
   asking another intake question.

2. **The look console — before a word o

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

Referenced files: 4 — file references are metadata, not package contents.

film-edit28.7 KB

View saved version →

---
name: film-edit
description: "Edit the film from selected takes to the cut the user calls final — scene assembly, evidence-based join repair, reshoot orders, review and the user's own final cut. Use for stages 7–8 once scenes have selects, or when the user wants a better join between existing clips. Routed from the film skill; a one-off montage uses the same compositor without the pipeline around it."
---

# ChatGPT and Codex integration

Apply these host conventions throughout this skill and its references.

- Discover the connected Picsart tools and use their actual names and schemas.
  The `picsart_*` names in the workflow identify tools, not a fixed host namespace.
  If the connection is missing, explain that Picsart must be connected; continue
  script and shot planning when possible. Never invent tool results or renders.
- Read board decisions from the current user message and attached widget context.
  Use `read_widget_context` only if the host actually exposes that tool. Do not
  assume ChatGPT has Claude's context reader. Treat a board's initial tool result
  and unsent widget state as previews, never as user approval. If a submitted
  decision has no accessible payload, explain briefly and use the text fallback
  to collect the missing decision; do not guess or repeat charged operations.
- Use the host's available question interface or one concise conversational
  question for preset choices.
- UI rendering and delivery of feedback are the remote MCP server's responsibility.
  If a board is unavailable, present its relevant options in text and record the
  user's selection using the same documented feedback fields. Do not claim that
  a plugin manifest makes Claude-specific widgets compatible with ChatGPT.
- Save `film.json` and artifacts in the user's writable project workspace, not
  the installed plugin directory. If persistent file tools are unavailable,
  keep a structured project checkpoint in the conversation and provide it for
  download when the host supports files. Never claim a file was saved without
  confirmation from a file tool.
- Honor the user's current instructions and already authorized scope. Preserve
  quoted spend limits and production locks; do not infer authorization from a
  preview, a timeout, or a connection being installed. A timed-out charged call
  needs a status check before considering a retry.
- This package holds six film skills (`film`, `film-development`, `film-assets`, `film-scenes`, `film-edit`, `film-finishing`) and three motion skills (`motion`, `motion-import`, `motion-design`). Route between them directly.
- `motion-import` reads a design's layers through the Figma app's tools. If Figma is not connected in this host, use its flat-frame fallback and say so once.


# Edit — takes → one review → the final cut

The editor's material is **selects only** — never the raw generation pile. And AI
editing has one structural difference from set footage: a reshoot costs minutes,
so **the edit runs in parallel with generation and actively orders shots**: "need
a cutaway to the hands", "need a wider size between 12B and 12C". Route those
orders back to `film-scenes` as new shot cards after checking the existing
coverage. For a bad join, first read **Join repair** below: a repair is not
automatically a model call. A new connecting insert can preserve both accepted
clips; it does not require re-rolling their run. Say what will change, what stays
untouched and the cost before any charged order (`film-scenes` step 5).

## Join repair — diagnose the pair before choosing the operation

When the user wants two existing clips to connect better, read
[JOIN-REPAIR.md](references/JOIN-REPAIR.md). Inspect both sides with sound and
actual boundary frames, explain the observed failure, and recommend the smallest
repair that addresses it. Missing story information needs a motivated beat, not
a cosmetic transition. Keep the accepted cut unchanged while comparing candidates.

## The automatic rough cut

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

Referenced files: 2 — file references are metadata, not package contents.

film-finishing6.17 KB

View saved version →

---
name: film-finishing
description: Finish a film after picture lock - the draft takes finished to full quality, colour matched and graded from the scene tools' looks, the soundtrack (the takes' own voices, an ambience or music bed), QC, masters, the archive and the AI disclosure. Use when a film's cut is final and it needs finishing, delivery files or its archive.
---

# Film finishing

Picture lock is behind you: nothing here changes the cut. The order is fixed and worth saying to the
user: **finish the draft takes → re-assemble → grade → export once → masters → archive.** Grading
a draft wastes the grade; exporting before the grade wastes an export. Read
`references/delivery.md` before QC, masters or the archive.

## Finishing the draft takes

Runs are shot as drafts (film-shot-generation), so the approved cut is finished before colour.
**The finish comes only after the user approves the draft cut, on its own quote and its own yes**:
the draft batch's quote showed it as an estimate, never as bought. Ask once: ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says) whether the
drafts are good enough for where the film goes, with the finish of every approved take priced
beside them: finish them, or keep the drafts. **That one question is the finish's quote and its
yes**; keeping the drafts skips this section. Only a model shot at its finish settings (no draft
setting and no lower resolution) has nothing to finish.

The finish, per take, in this order of preference:

- **A draft that returned a `finalizeDraft` handle** (Seedance 2.5): send its arguments unchanged,
  with the draft's prompt. It renders the same take at the finish settings instead of a fresh
  roll, so the approved performance and trims hold. The handle lasts 7 days; an older draft takes
  the next route.
- **No handle:** an upscale where one fits, a separate model chosen from `picsart_model_catalog` at
  the time (none is named here); or the approved run **generated again at the finish settings with
  its saved final prompt, verbatim**: same blocks, same references, the model's final settings as
  `picsart_model_params` names them. Say it before it runs: this is a **fresh roll**, not an
  upscale. Small differences from the draft are expected. Where a re-roll breaks something the draft
  had (a face, a join), that is a repair on the final take (film-shot-generation), logged and fixed.

Every approved take is finished in one batch, on that one yes, and a repair made during the draft
review is finished with the rest. Upscale first, then texture, then grade: every correction
touches the highest-resolution pixels. Then re-assemble the locked cut at the finish size
(film-cutting), with the user's trims unchanged. A cut with a fresh roll in it is shown once more
before colour: its differences from the approved draft are the user's to see.

## Colour: match, then grade

Every generation carries its own baked-in grade, so the first job is **matching** neighbouring shots
of each scene, and only then the look. The film's tone already lives in its places' pictures, so
the grade refines it and never invents a new one.

- Read the real looks from `picsart_scene_capabilities` with `sections: ["looksCompact"]`
  (never a remembered look name, and never the full `looks` section, which can overflow), and
  return three or four that suit the film's colour.
- The user picks the look: apply each of them to one representative scene and show the versions
  in `picsart_scene_picker`, each card labelled in their terms ("warm dusk", "cool and muted"),
  never a `look:<id>`. Never choose for them or describe the looks in text; grade th

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

Referenced files: 1 — file references are metadata, not package contents.

film-scenes110 KB

View saved version →

---
name: film-scenes
description: "Generate the film's shots — the shooting period. Final per-scene shotlists, preset-driven shot design (camera moves, optics, two-source lighting, acting), every scene's pictures on one board (scene picture, wide, a room map when needed), the handbook's two-part prompt — one prompt per RUN of shots (as much of the film as fits a single generation, scenes included), the model making the cuts inside it — drafts, surgical iterations with a full log, the delivered run split back into its shots, and take selection into selects. Use for stage 6 of the film pipeline, only after the scenes' asset sheets are approved. Routed from the film skill."
---

# ChatGPT and Codex integration

Apply these host conventions throughout this skill and its references.

- Discover the connected Picsart tools and use their actual names and schemas.
  The `picsart_*` names in the workflow identify tools, not a fixed host namespace.
  If the connection is missing, explain that Picsart must be connected; continue
  script and shot planning when possible. Never invent tool results or renders.
- Read board decisions from the current user message and attached widget context.
  Use `read_widget_context` only if the host actually exposes that tool. Do not
  assume ChatGPT has Claude's context reader. Treat a board's initial tool result
  and unsent widget state as previews, never as user approval. If a submitted
  decision has no accessible payload, explain briefly and use the text fallback
  to collect the missing decision; do not guess or repeat charged operations.
- Use the host's available question interface or one concise conversational
  question for preset choices.
- UI rendering and delivery of feedback are the remote MCP server's responsibility.
  If a board is unavailable, present its relevant options in text and record the
  user's selection using the same documented feedback fields. Do not claim that
  a plugin manifest makes Claude-specific widgets compatible with ChatGPT.
- Save `film.json` and artifacts in the user's writable project workspace, not
  the installed plugin directory. If persistent file tools are unavailable,
  keep a structured project checkpoint in the conversation and provide it for
  download when the host supports files. Never claim a file was saved without
  confirmation from a file tool.
- Honor the user's current instructions and already authorized scope. Preserve
  quoted spend limits and production locks; do not infer authorization from a
  preview, a timeout, or a connection being installed. A timed-out charged call
  needs a status check before considering a retry.
- This package holds six film skills (`film`, `film-development`, `film-assets`, `film-scenes`, `film-edit`, `film-finishing`) and three motion skills (`motion`, `motion-import`, `motion-design`). Route between them directly.
- `motion-import` reads a design's layers through the Figma app's tools. If Figma is not connected in this host, use its flat-frame fallback and say so once.


# Scenes — the shooting period

This is where the money goes, so it runs as a seven-step conveyor per scene, in
order, because each step is more expensive than the one before it. The gate behind
you is real: **no run generates until the assets of every scene it spans are
locked** (the matrix in `film`) — a run that crosses a production-block boundary
waits for both blocks, so where the film works block by block, the run pass cuts
runs at block boundaries. The gate ahead: every shot `final`, in selects, logged.

**Nothing charged in video goes out on a number the user has not seen and said
yes to (2026-09-07).** Reported from real sessions: runs dispatched with no
credit figure in front of the user at all. Video is the film's largest spend, so
every charged video call — the pilot run, the batch, a re-roll, an edit, an
extend, the final-resolution pass — happens in three steps in this order:
`picsart_preflight` (free) returns a number, the number g

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

Referenced files: 6 — file references are metadata, not package contents.

film-shot-generation17.1 KB

View saved version →

---
name: film-shot-generation
description: Shoot a film's shots as runs - narrowing the video models a film can use, packing shot cards into multi-shot generations, drafting key frames before footage is bought, compiling and verifying every prompt on the server, following the jobs, and routing notes to an edit, an extend or a re-roll. Use when a film's video models are narrowed, or its shots are planned into runs, pictured, generated, checked or repaired. A film the user makes step by step here is carried on by its own use case, which loads this skill when a step needs it.
---

# Film shots

Author every shot on its own; generate them together. The unit of generation is the **run**: as
much of the film as fits one generation at the model's ceiling, scenes included. The model makes
the cuts inside it. The cuts it actually made are found and checked against the plan, and the
take goes into the cut whole, as generated (film-cutting). Read these
before the step:

| File | Read it before you… |
|---|---|
| `references/seams.md` | write how one shot meets the next, or where one run meets the next |
| `references/camera.md` | choose or write a shot's camera move |
| `references/realism.md` | write a shot's action, sound and what persists through a run |
| `references/scene-pictures.md` | make a scene's wide, scene picture or room map |
| `references/references.md` | put a run's reference images together |
| `references/takes.md` | check a take's cuts, or judge one |
| `references/repairs.md` | act on a note about a take |
| `references/seedance.md` | compile, repair or extend anything on a Seedance model (`seedance-…`); then load the `sd25-pe` skill for Seedance 2.5 or `sd2-pe` for Seedance 2.0 |

## The model

One video model shoots the whole film, and the runs are packed against its ceiling, so choose it
before the shots are planned.

1. Narrow the video models with `picsart_model_catalog`: `mode: "video"`, `purpose: "generate"`,
   `concise: false`. Keep the rows whose `supportedAspectRatios` hold the film's ratio. Edits,
   extends and upscalers are out. Never filter on `acceptsImage`: the catalog marks models that
   take reference images as text-to-video (every Seedance), so the filter hides them. A model
   takes the cast's views when `picsart_model_params` lists `imageUrls` or `startFrame`. A use case
   or host that names its candidates or the film's model replaces this narrowing; steps 2 and 3
   still run on what it names.
2. Read `picsart_model_params` on each model that survives. Keep only those that hold
   **several cuts inside one generation** at the finish resolution and take enough reference
   images for a run. Note each one's draft setting (Seedance 2.5's `draft`) or, without one, its
   lowest resolution: the first batch is shot at it.
3. For each one kept, find its edit and extend siblings: the `picsart_model_catalog` rows (`concise: false`) from the
   same provider with `purpose: "edit"` that edit or extend a clip. Repairs use them.

## Runs

**Packing.** Read the model's ceiling and accepted durations with `picsart_model_params`; never
from memory. Pack the ordered shots into the fewest runs that fit. A scene change, a climax, a
close-up or a hunch that a shot works better alone is not a reason to start a run. Merge adjacent
runs that fit together, and say which you merged.

**Durations.** A shot's `sec` is its length in the cut. A run's generation length is the sum of its
shots' `sec`, snapped up to a duration the model accepts. That is the run's `genSec`. The take
plays whole in the cut and nothing trims it unless the user does, so the prompt describes the
action from the first frame to the last: no calm beat padded at either end. Inside a run, the
silence after a line and a designed tail hold play as screen time.

- The ceiling is a packing limit, not a shot length. Never merge several short actions into one
  long shot to fill a run.
- Dramatic shots run three to eight seconds, action shorter. A shot ove

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

Referenced files: 9 — file references are metadata, not package contents.

film-story-writing5.63 KB

View saved version →

---
name: film-story-writing
description: Write a short film's story and break it down - pre-setting the look from the idea, the ten-line story and every scene as what the viewer sees and hears, dialogue that performs action, one light per scene with its dark side and a colour kept back, and the shot cards and asset tags that come out of it. Use when a film needs its look suggested, its story written or rewritten, or its story turned into shots and assets.
---

# Film story

The story is written for the viewer, in the viewer's words. The shot list is written from the
story and never the other way round. Read these before the step they serve:

| File | Read it before you… |
|---|---|
| `references/story.md` | write or rewrite the story, or its viewer track |
| `references/dialogue.md` | write a spoken line |
| `references/breakdown.md` | turn the story into shot cards and asset tags |
| `references/look.md` | suggest a look, or use the user's reference images |
| `references/light.md` | set a scene's light on its cards, or keep a colour back for one moment |
| `references/writers-room.md` | the user asks for a writers' room, or for several drafts to choose from |

## Suggest the look from the idea

The look comes before the story, because genre decides how the story is told. Pre-set
`picsart_film_setup` from the idea with `suggested`, one line of `why` per value:

- **The genre the events make.** Two people fighting is action; two people talking is drama. A
  custom genre is the user's own words.
- **A tone only when the story names a period or a tradition of cinema.** A tone is an era recipe:
  it sets the rig, not the colour. Otherwise leave it on auto. The console expands a tone into its
  camera and lens pills before applying any pill you also name, so an explicit `camera` or `lens`
  wins over the tone's.
- **Only the console's own controls.** The lens is a glass family, never a focal length. Focal
  length, aperture, framing, shot length and camera movement are per-shot choices on
  `picsart_film_shotlist`; grain rides in the camera preset; pace is written per shot, never set.
  Ids the console does not have are ignored, not guessed at.
- **The colour only when the idea names one**: one line of direction as `paletteHint`, written as
  a scheme around a hue ("analogous around amber"). The console shows it as a hint and applies
  nothing; it has no palette to pre-set. The colour is the user's; suggest, never decide it.
- **The frame from the user's own words** (`vertical`, `9:16` and `tiktok` resolve the same), and
  the runtime they said. The console offers only the five frames video models render broadly
  (16:9, 4:3, 1:1, 3:4, 9:16): for scope or 21:9, shoot 16:9 and crop in the edit.
- **Where each goes.** `film` (the title) is required, and `paletteHint` is its own top-level
  argument. Genre, tone, `ratio` and `duration` all go inside `suggested.selections`, in those field
  names, never as top-level arguments: the schema allows nothing else. The `why` lines go in
  `suggested.why`, keyed the same way.

Pass only what the material answers and leave the rest on the console's defaults: a wrong prefill
reads to the user as a decision someone already made. The console's presets are its own; choose ids
from it and never write a preset's text yourself.

## Write the story

Ten lines at the top, then every scene in order, as `references/story.md` says. Before you show
it, check:

- the thing the story is about is seen in the first scene;
- who holds what, and where people are, is visible, not implied;
- the events belong to the genre;
- nothing contradicts what the user's brief fixed;
- every scene has action, and every object belongs to the world and its period.

These are your checks as the writer, never a stranger's read. Then write the film's viewer track
(`references/story.md`): what a viewer who knows nothing must get, and by when. Whether a stranger
gets it is decided by quality-review's cold watch on the animatic and

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

Referenced files: 6 — file references are metadata, not package contents.

footage-analysis3.19 KB

View saved version →

---
name: footage-analysis
description: Watch the user's own talking footage and turn it into facts you can build on - its moments worth keeping, who is on screen, and a transcript whose sentences set every cut - read every source at once and follow the job receipts. Use when a use case needs to know what happens in an interview, podcast, vlog, talk or any footage of people speaking, and when. A screen recording's pictures are read by the screen-recording-analysis skill; only its spoken narration is transcribed here.
---

# Media analysis

Know what the footage shows, and when, before you build on it. This skill reads people talking to
camera, an interview, a podcast or a vlog; read `references/talking-footage.md` before you watch it.
A screen recording is read from its pixels, as the screen-recording-analysis skill says. When it carries the user's own narration, that speech is
transcribed here like any talking footage, and nothing in it is watched.

## Watch

1. `picsart_media_probe` on the file: dimensions, duration, and whether it has audio. It
   reports container facts only, never what is shown.
2. `picsart_media_describe_video` with the use case's request as its `question`, asking for JSON,
   not prose. It charges credits on every call, so the use case gets consent before it runs. Read its
   `answer`. Apply picsart-video-rules's SPEND rule to each tool's billing contract.
3. Unless the probe reports `hasAudio: false`, and when the narration is worth quoting,
   `picsart_media_transcribe` the file. The probe leaves `hasAudio` out when it cannot tell, and
   that is not a no.

The probe and the watch do not depend on each other; run them at the same time. **The watch is
critical.** If it fails, or its `answer` is not the JSON you asked for, retry the same call once.
If that fails too, tell the user the service is down and to try again shortly. Never guess the
content from nothing.

**The watch and the transcript reply with a job receipt**, not the result: follow it as picsart-video-rules
says.

**With several sources, read them all at once.** Every video gets its own probe, watch and
transcript, and none waits for another. A photo gets only the probe, for its size: it has no
speech and nothing happens in it over time.

## Talking footage

When people speak, the two reads have different jobs:

- **The transcript is the only source of where a thought starts and stops.** Transcribe every
  spoken source, with `speakers: "auto"` when more than one person may speak. Save the result
  verbatim as `transcript-<source id>.json` and pass that file to the scripts that need it; keep
  only the segment list in mind, never every word.
- **The watch says what is worth keeping**: the strong moments, the dead stretches, who is on
  screen. Its sense of the audio is the gist, never a boundary.

**An empty transcript means no speech**, not a failure to retry. Nor is a thin one a transcript
to cut on: segments covering a sliver of the runtime, or none with word times. Say in one line
that the footage has almost no speech, and let the watch's moments set the boundaries.

The watch's idea of where a person sits is an estimate. Never frame a crop on it: the footage-reframing
skill measures the subject from the footage.

Referenced files: 1 — file references are metadata, not package contents.

footage-reframing15.3 KB

View saved version →

---
name: footage-reframing
description: Put the user's own footage in a frame of another shape - landscape to a vertical reel, say - with the camera on the right person - measured once per source, checked and corrected by hand where the tool fails (a subject cut off, the wrong speaker, a late or jittery camera), then cut into a reel with scripts/reel_cut.py, so any re-cut is free. Use whenever footage is reframed or a reframe is checked - a reel or short from the user's own videos and photos, a landscape video reposted as a vertical one - or when a reframe or vertical crop misframes the subject.
---

# Reframe

A vertical crop of a landscape shot keeps about a third of its width. Centred, that third is often
a wall beside the speaker. So the subject's position is measured, never guessed, then checked and
corrected where the tool got it wrong, and the clips are cut from that path by a script.

This skill owns all reframing: the tool call, the check, the correction and the cut. A use case
that reframes loads it and keeps no reframing method of its own.

## Measure each source once

1. **Which sources need it.** A video whose shape differs from the reel's, with a person or
   another subject in it. A source already the reel's shape, and one with nothing to follow (a
   title card, a full-frame graphic, a wide shot with no subject), needs no reframe: its clips are
   `full`.
2. **Reframe it.** `picsart_media_reframe_video` with the source's Picsart-hosted `url` and the
   reel's `aspect_ratio`. It replies with a job receipt, followed as picsart-video-rules says. It
   takes minutes, so post a line first, and
   start it as soon as the source and the reel's shape are known. It does not need the cut.
   A local file or a Drive file is used by its Picsart-hosted URL, as picsart-video-rules says
   for asset URLs; every check below reads that same URL.
3. **Keep the result verbatim**, the whole reply: as `reframe-<source id>.json` where you run
   commands, else in the project record. Never pass
   `scene` and `layer_id` for this: that mode refuses a trim, and every call measures again.

**One reframe per source and shape, for the whole session.** The result covers the source's whole
length, so every clip, every re-cut and every new running order is windowed from it by the script.
Measuring again for a new cut repeats minutes of work and changes nothing. Its description says
whether it charges credits. If it does, it is a SPEND (picsart-video-rules): quote every source's reframe in
one go.

If it fails, retry it once: it is flaky, and a later try often succeeds. If it fails again, stop
and say the reframing is unavailable right now, with what is ready. Never estimate the subject's
position from a description of the video, and never frame a talking person `full` as a stand-in.

## Check and correct

The tool follows a face, or else the most salient region, frame by frame. It does not know who is
speaking, what the story needs kept, or where the platform's buttons sit. **Check every reframe
before cutting from it, and correct what fails.** Never pass a reframe on unseen, and never measure
again hoping for a better one: the same footage gives the same path.

| Failure | What it looks like | Finding |
|---|---|---|
| Subject cut off | a head, a chin or the hands past the frame's edge, or under the platform's buttons | `cut-off` |
| Wrong person | the camera on the listener, or never switching to the new speaker | `wrong-person` |
| Late or jumpy cut | the camera reaches the speaker a second into their line, or leaps where nobody new speaks | `late-cut`, `jumpy-cut` |
| Jitter or wander | the window trembles, or drifts across a speaker who sits still | `jitter`, `wander` |
| Lost detail | a product, a sign or on-screen text the story needs, outside the frame | `cut-off` on a `keep` subject |
| Soft picture | zoomed in so far the picture turns soft | `soft` |

### What to read

- **Where each subject is.** One `picsart_media_video_stills` 

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

Referenced files: 3 — file references are metadata, not package contents.

generate-media12.7 KB

View saved version →

---
name: generate-media
description: Make an image, a video, a voice line, a sound or a song from a prompt, or edit a picture or product photo - remove or replace its background, enhance or upscale it, or turn it into a vector - with a model that fits, its settings checked and its price quoted before anything is charged. Also answers questions about models, prices, credits and Drive. Use when the user asks to generate, make or create an image, a video or audio, to edit a picture, to browse the models, or about a price, their credits or their Drive files. Load it first, before any tool, when they say not to ask, to work unattended, or set a spend limit. Load it before calling any Picsart model, generation or image tool.
metadata:
  uses: film-shot-generation, sd25-pe, sd2-pe
  title: Generate media
  short-description: Make or edit images, video, voice, sound and music
  argument-hint: '[what to make or edit]'
  starter-prompt: Make an image, a video or audio from my prompt.
---

# Make or edit an image, a video or audio

Read picsart-video-rules first. One job: the user asks for one piece of media, or one edit of a picture,
and gets it with no failed call and no surprise charge. A whole video project is another use case:
when the user wants their footage cut, a screen recording turned into a video, a film or an
animated design, start that use case instead.

Before acting on a stage, load the skills in its row that apply to this job, also when the work resumes there.

| Stage | Gate | Skills |
|---|---|---|
| 1. What to make, and from what | ASK | — |
| 2. The user's files, as URLs | — | — |
| 3. The model and its settings | ASK | film-shot-generation, sd2-pe, sd25-pe |
| 4. The quote | SPEND | — |
| 5. Run it | — | film-shot-generation |
| 6. Show it | SHOW | — |

A question that makes nothing (which models there are, a model's settings, a price, the balance, a
Drive folder) skips the stages: answer it as **Questions that make nothing** says, and charge
nothing.

## 1. What to make, and from what

Read the request before you ask (picsart-video-rules's Asking). Most say all of it: the medium, the
subject, and any picture or clip to start from. Say back what follows from it in one line ("a 9:16
image for a story"). ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says) only for what is open and changes the result: the medium when it is not
said, the frame when the destination does not set it, a voice or a song when "audio" is not said.

An edit names its tool by what it does to the picture:

| The user wants | Tool | Its input |
|---|---|---|
| The background removed, the subject cut out | `picsart_image_remove_bg` | `image` |
| The background replaced ("put it on a beach") | `picsart_image_change_bg` | `image`, and `prompt` for the new background |
| Sharper, cleaner or bigger ("make it 4k") | `picsart_image_enhance` | `image`, and `scaleFactor` when they gave one |
| A vector, an SVG | `picsart_image_vectorize` | `image` |

Each picks its own model. Before a vector of a photo, say once that photos vectorize poorly and
logos, icons and simple graphics well. Anything else is made with `picsart_generate`.

## 2. The user's files, as URLs

Every input is a URL: `image` on the edit tools, `imageUrls` and `videoUrl` on `picsart_generate`.
A URL a Picsart tool returned in this conversation is passed as it is, except a HEIC photo's (picsart-video-rules's Asset URLs).
Otherwise:

- **A file on disk, and you can run shell commands:** call `picsart_upload_local_files` with each
  file's `name` and `bytes`, run each command it returns with the path in place of `{path}`, and
  read the UR

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

Referenced files: 1 — file references are metadata, not package contents.

get-started4.97 KB

View saved version →

---
name: get-started
description: Get started with Picsart Video - check that your Picsart account is connected and how many credits you have, open Picsart beside the conversation where the host can, and see what you can make and edit. Use when the user has just installed Picsart or Picsart Video, asks to set it up, asks what it can do, or asks how to get started.
metadata:
  uses: open-picsart-app
  optional: open-picsart-app
  title: Get started
  short-description: Connect your account and see what Picsart can do
  argument-hint: '[what you want to make]'
  starter-prompt: Show me what Picsart can do.
---

# Getting started with Picsart Video

Read picsart-video-rules first. One job: in a turn or two, the user knows their account works, has their
Picsart open if they want it, and knows what to ask for next. Nothing here charges credits.

If the user installed Picsart Video in the middle of a task, do stage 1, then go back to that task
in the same conversation. Offer the rest in one line at the end instead.

Before acting on a stage, load the skills in its row that apply to this job, also when the work resumes there.

| Stage | Gate | Skills |
|---|---|---|
| 1. The account and the credits | — | — |
| 2. Open Picsart, when the host has it | ASK | open-picsart-app |
| 3. What Picsart Video does | — | — |
| 4. Where to start | ASK | — |

## 1. The account and the credits

Call `picsart_credits` with `{}`.

- **It answers:** say in one line that the account is connected and give the balance as the tool
  returns it. Never round it, add it up or guess it.
- **It says the user is not signed in:** say that making and editing need a signed-in Picsart
  account, and that the host will ask them to sign in the first time a step needs it. Go on with
  stage 3, and skip stage 2 until they are signed in.
- **It fails otherwise:** say that the balance could not be read right now, and go on.

## 2. Open Picsart, when the host has it

Only when the open-picsart-app skill is among your skills: offer it as that skill says. Without it,
skip this stage and say nothing about it: not every host can open Picsart beside the conversation.

## 3. What Picsart Video does

Say it in three short parts, in the user's words. The tools in brackets are for you, never for the
user (picsart-video-rules's Tools).

- **Drive.** Their files, stored with their Picsart account: browse them, search them in
  Picsart, make folders, move and delete (a deleted file goes to the trash first).
  The `picsart_drive_*` tools do this (`picsart_drive_list`, `picsart_drive_create_folder`,
  `picsart_drive_move`, `picsart_drive_delete`). When they bring a file of their own, it comes in with
  `picsart_drive_upload_ask`. Their saved characters, locations, templates and looks (scene documents)
  open in the same browser with `picsart_scene_library_list`.
- **Create.** Images, videos and audio from a prompt, with a choice of models. They can pick a
  model themselves (`picsart_model_show`), and every creation is quoted before anything is
  charged (`picsart_preflight`, then picsart-video-rules's SPEND).
- **Edit.** For an image: remove the background (`picsart_image_remove_bg`), replace it
  (`picsart_image_change_bg`), enhance it (`picsart_image_enhance`) or turn it into a vector
  (`picsart_image_vectorize`). For a video: a scene editor where they watch it, trim, split and comment,
  and approve it before it is exported (`picsart_scene_editor`, picsart-video-rules's REVIEW).

Edits charge credits too; each is quoted first. Say that once, not per item.

## 4. Where to start

Offer the use cases in this package that fit the user, in their words. Name only use cases that
are here: look at the skills you have, not at this list. Today they can include:

- `generate-media`: one image, video, voice line, sound or song from a prompt, or one edit of a
  picture;
- `make-screen-videos`: a screen recording of an app or website becomes how-to shorts, a promo or a
  tutorial;
- `animate-de

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

Referenced files: 1 — file references are metadata, not package contents.

large-scene-assembly7.75 KB

View saved version →

---
name: large-scene-assembly
description: Build large editable scenes by decomposing a timeline into bounded scenes and reusable components, defining timing and asset contracts, then assembling and safely consolidating them. Use when authoring long videos, many scenes or layers, scene-by-scene designs, oversized JSON, fragile whole-document edits, reusable modules, or an editable handoff.
metadata:
  category: workflow
  version: '1.1'
  ported-from: large-scene-authoring 1.1 at 55.75.0
---

# Large scenes, small editing units

Served checks: `picsart_scene_check_contracts` runs contract records and reusable templates, `picsart_scene_check_motion` runs frame-complete motion records, and `picsart_scene_inspect` pages large sources; the one remaining limit is that pixel records have no automated checker, so inspect full-resolution rendered frames for them.

Keep one editable source of truth and a thin assembly. Decompose by meaning and ownership, not an
arbitrary layer count. A card that travels across three beats is one persistent object, not three
separate scenes just because the storyboard has three frames.

## Establish a manifest before growing the document

Record canvas/fps, ordered beats and durations, shared style tokens, component ids, assets, entry/exit
states, and the carrier (if any) across each seam. Use the compact
[scene manifest](references/scene-manifest.md) when the timeline needs a durable handoff.
The manifest is authoring documentation, not an extra field injected into the scene schema.
Record checkable intent in a separate versioned contract sidecar (`linked-element-motion`), with
stable contract ids, query target scopes and root-time phase windows. The same element may have
different relationships in different phases; document independent travel rather than forcing one
parent relationship for its whole lifetime. Preserve these contracts alongside component revisions.

Choose boundaries deliberately:

| Unit | Representation and ownership |
|---|---|
| Local semantic unit: card, label, icon | Inline `composition` or a supported parent rig; animate its common placement once. |
| Reusable independent scene | Scene asset/reference with explicit inputs, duration, dimensions and assets. |
| Sequential beats | `track` clips; record how clip windows map into source time. |
| Persistent foreground across beats | Parent-level layer spanning the interval, outside the replaced clips. |
| Shared styling | Consistent authoring tokens/parameters; do not assume implicit inheritance between documents. |

Ask `picsart_scene_capabilities` (`schema:<Name>` sections) for the exact relevant content/asset/parameter shapes. An inline composition
uses its owning document's assets; a separately referenced scene owns its own asset scope. Do not
rely on an undeclared parent asset, copied font id, or temporary URL being available in a child.

## Author → verify → assemble, incrementally

1. Build each semantic component with editable shapes, text, assets, keyframes and stable ids. Validate it with `picsart_scene_validate` and query entry, event and exit geometry with `picsart_scene_query_layout`.
2. Inspect full-resolution stills with `picsart_scene_contact_sheet`, setting `resolution` to the scene dimensions; watch continuous video for motion claims.
3. Preserve the accepted source revision and record its returned source or handle. A held handle is local to its tool surface, not a portable published URL.
4. Assemble a thin root that owns order, clip windows, seams and persistent carriers. Children own their internal layout and motion.
5. Check just before, at and after joins. Rerun supported `picsart_scene_lint_layout` relationships against independently recorded intent. Rerun contract records with `picsart_scene_check_contracts`; record uncovered assertions as unchecked.
6. Continue component by component; recheck affected joins and overall playback. Show meaningful milestones during authorized autonomous iteration.

## Keep edit

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

Referenced files: 1 — file references are metadata, not package contents.

linked-element-motion23.1 KB

View saved version →

---
name: linked-element-motion
description: Keep related scene elements aligned and moving together, including container resizing, shared fades, content reveals and sibling reflow. Use when labels detach, companions fade separately, panels fail to grow, content overflows, or an outside object must join a template at a particular time and remain attached.
metadata:
  category: authoring
  version: '1.7'
  ported-from: layout-choreography 1.7 at 55.75.0
---

# Layout relationships through motion

Served checks: `picsart_scene_check_contracts` runs contract records and reusable templates, `picsart_scene_check_motion` runs frame-complete motion records, and `picsart_scene_inspect` pages large sources; the one remaining limit is that pixel records have no automated checker, so inspect full-resolution rendered frames for them.

Editable layers are not necessarily independent motion units. Before animating, state which things
belong together, which may change internally, and what must make room when new content appears.

## Construct the relationship before checking it

Choose the construction from how long the relationship must hold:

- **Always one motion unit:** put the plate, label and icon in one composition/scene reference;
  animate that owner once. Leave children in local coordinates. Use `parentId` for transform-only
  ownership when appropriate; it does not inherit opacity or lifetime. A shared fade belongs on
  the enclosing composition owner. Do not copy the same travel/press/exit tracks onto every child.
- **Always one layout rule:** declare shared width, height, padding and offsets, then derive the
  backing size and child placement from them. In a parameterized scene, use `$eval` expressions
  such as `height / 2` for the label center as well as the backing center. Resizing an instance
  then changes one binding instead of several unrelated coordinates. `$eval` resolves parameters;
  it is not a per-frame read of another layer's animated geometry.
- **A property follows another each frame:** use the supported Lua property-read API when the
  dependency is needed and a common owner is insufficient. Fetch `scene-animation-reference` for syntax,
  scope, coordinate and clock limits. Keep the dependency one-way; do not invent reactive fields
  or use another layer's local placement as if it were a root-space painted center.
- **Related only during a phase:** keep intentional independent motion, derive the attached phase
  from one path/progress source, and declare when it releases. Use time-windowed contracts for
  those phases and inspect the handoff. Static parenting is not an animated reparenting switch.

Contracts verify the construction; they do not create the relationship. For a simple rigid widget,
prefer one owner and a shared sizing formula over independent tracks plus many corrective checks.
Still verify initial layout, realistic parameter edits and the final painted result: parenting can
preserve an incorrect offset, and a shared formula can encode the wrong design.

## Assign motion and layout ownership

| Relationship | Authoring choice | Evidence |
|---|---|---|
| Panel + label + icon travel together | One inline composition or supported parent rig; common transform on the owner | Constant relative offsets during translation; inspect scale/rotation separately |
| Badge enters inside a moving card | Common card placement plus deliberate badge-local entrance | Card trajectory plus badge's local event window |
| Panel grows for another row | Animate panel geometry independently from text; move following rows/siblings explicitly | Fixed edge, attached gaps and padded containment throughout resize |
| Whole unit changes scale | Scale the semantic group intentionally | Text, stroke and corner appearance in rendered frames |
| Same object crosses a scene boundary | Keep the owner alive across the seam | Presence window and continuous video |
| Label on a plane in depth | Label is a child of the plane by `parentId`,

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

Referenced files: 2 — file references are metadata, not package contents.

make-cartoon13.7 KB

View saved version →

---
name: make-cartoon
description: Make a short cartoon clip with a character the user picks or describes - one 9:16 video of 8 to 20 seconds with one or two characters in one place, who walk in, wave, reach, hold or carry a prop, and a narrator's voice-over. A character is picked from the ready-made cast or the user's saved library, or described, drawn as two turnaround sheets, picked, built into an editable cut-out rig and checked on a short test render, then saved for reuse. Use when the user wants a cartoon, an animated character or a mascot clip, a kids' story beat, or a short scene with their character. Not for a character's sheet with no scene (make-character), nor for a drama with several scenes (make-short-drama), nor for motion on a design (animate-design).
metadata:
  uses: character-rigging, scene-building-basics, voice-over-generation, background-music, motion-review
  optional: background-music
  title: Make a cartoon
  short-description: Cast a character and make a short animated scene
  argument-hint: '[who is in it and what happens]'
  starter-prompt: Make me a short cartoon with a character.
---

# Make a cartoon

Read picsart-video-rules first. One job: one short cartoon clip, 9:16, 8 to 20 seconds, one or two
characters, one place, with a narrator's voice-over. The characters do not speak on screen, and
nothing here turns, sits, hugs, claps or hands a prop to another character: reword such a beat or say
"not yet". More than two characters, a second place, more than 20 seconds or another ratio is a
different job: say so before starting.

Before acting on a stage, load the skills in its row that apply to this job, also when the work resumes there.

| Stage | Gate | Skills |
|---|---|---|
| 1. The plan | ASK | scene-building-basics |
| 2. Cast | ASK, SPEND, REVIEW | character-rigging |
| 3. Place | SPEND | scene-building-basics |
| 4. Prop | SPEND | character-rigging |
| 5. Build the scene | SPEND | character-rigging, scene-building-basics, voice-over-generation, background-music |
| 6. Review | REVIEW | motion-review |
| 7. Export | DELIVER | scene-building-basics |

## 1. The plan

Turn the request into one short paragraph and ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says) the user to approve or edit it in one turn: who (one
or two characters), where (one place), what happens in 3 to 5 beats, and the narration lines. A beat is
one of: walk in or out, idle, wave, reach, pick up, hold or carry a prop, put it down, jump, jog.
Think and hand-over join the list when `picsart_scene_capabilities` shows them. Read the allowed actions
from `picsart_scene_capabilities`, not from memory: a beat it does not list is reworded or refused.

## 2. Cast

One character at a time. Look in the user's saved library first with `picsart_scene_library_list`
(`kind: "character"`), and offer the ready-made cast from `picsart_scene_capabilities`. ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says) which:
a saved or ready-made one, or a new one described in their words.

**Pick.** A saved character is a scene in the library: place it with `picsart_scene_apply_template`,
`uri: "library:<libraryId>"`, so a second scene with the same character is identical. A ready-made one
is placed with `picsart_scene_apply_template` too, wit

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

Referenced files: 1 — file references are metadata, not package contents.

make-character6.01 KB

View saved version →

---
name: make-character
description: Make one AI character with no film - a person or an animal drawn as one photoreal reference sheet, the canvas's strip (full-body front, side and back, and a large face close-up, in one row), its look picked from Picsart's ready-made characters, a person and an outfit, or the user's own words, approved, then saved to their Picsart Assets where Picsart's canvas finds it too. A character maker for an AI influencer, a mascot or a recurring face. Use when the user wants an AI character, a character sheet or a consistent face of their own, with no story around it. Not for a film's cast (movie-producer), nor for a single picture of someone (generate-media).
metadata:
  uses: film-cast-design
  title: Make a character
  short-description: Design one consistent character and save it to your Assets
  argument-hint: '[who they are, or a photo of them]'
  starter-prompt: Make me an AI character.
---

# Make a character

Read picsart-video-rules first. One job: one character, with no film, as one approved sheet saved to
the user's Assets. A film's cast is movie-producer's; a single picture of someone is generate-media's.

Before acting on a stage, load the skills in its row that apply to this job, also when the work resumes there.

| Stage | Gate | Skills |
|---|---|---|
| 1. Who they are | — | film-cast-design |
| 2. Their look | ASK | film-cast-design |
| 3. The quote | SPEND | film-cast-design |
| 4. The sheet | REVIEW | film-cast-design |
| 5. Save it | DELIVER | film-cast-design |

## 1. Who they are

Draft the character's descriptor from the user's words, as film-cast-design's Descriptors says:
line-keyed, concrete, what you invented marked as a proposal. Give them a name and an @tag from it.
They have no voice line: this character is not cast to speak.

When the user brings a photo of the real person, the photo is the character, as film-cast-design's
`references/own-photos.md` says: skip stage 2, and keep the photo's own style.

## 2. Their look

ASK with `picsart_film_choose_cast`, with no `film` and this one character: their @tag as `id`,
`name`, who they are as `role`, and the descriptor's lines as `story`. The card opens on the
ready-made characters, with the look you `suggested` picked, and keeps your lines on its story tab.
Then act on `film_cast_chooser_feedback` as film-cast-design's The starting point says:
`story` keeps your draft. A `preset` with `saved` reuses that asset without compiling or spending; deliver the saved character and skip the quote and generation steps below.
For an unsaved `preset`, quote the sheet’s credit cost, compile with `sheetModel`, and save under
the preset’s own name so the next pick reuses it. An unsaved `preset` and `person` pass their `reference` on unchanged with only the
`fromStory` paths added from your draft, and `describe` rewrites the draft from their words.

## 3. The quote

1. Use picsart-video-rules's image default unless the user chose another model; check its inputs
   and supported ratios with `picsart_model_params`.
2. Compile the sheet with `picsart_film_compile_prompt`, `kind: "sheet"`, that model as `model`,
   and the descriptor in `reference`. The look is the Picsart canvas's style line:
   `look: { "customTone": "clean photoreal reference sheet — realistic materials, soft even light ~5500K" }`.
   With a photo, the photo's style is the style: add
   `"usePhoto": true, "customMedium": "the reference image's own medium, kept as it is"` to
   `reference`, and pass
   `look: { "customTone": "the exact art style of the reference image — its medium, rendering, linework, shading, palette and level of detail, with no realism added" }`.
   Put the supplied original photo URL in `verifyWith.request.imageUrls` and in the actual
   generation's `imageUrls`, including on replacements. `usePhoto` alone attaches no image.
   Never leave `look` out: a sheet with no style line is refused. Send the prompt and supported
   `aspectRatio` as returned, at th

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

Referenced files: 1 — file references are metadata, not package contents.

make-comics17.7 KB

View saved version →

---
name: make-comics
description: Turn a photo into a ComicMe creation - a comic of drawn pages, an illustrated tale, a video comic or video tale, a short reel, a narrated quote video or an anime series from several photos - with the person in the photo as its hero, a second person from a second photo if they want one, in a genre, art style and tone they pick, with the price said before anything is charged and every page or clip shown when it is made. Use when the user wants a comic, a tale, a reel, an animated video or a series made from a photo of themselves or someone else, or asks what they would look like as a comic hero.
metadata:
  title: Make comics
  short-description: Turn a photo into a comic, tale, video, reel or anime series
  argument-hint: '[the photo and the comic you want]'
  starter-prompt: Turn my photo into a ComicMe creation.
---

# Make a comic from a photo

Read the `picsart-video-rules` skill first. One job: a photo of a person in; a ComicMe creation
out, with the person as its hero. ComicMe makes six things from a photo, each through its own
tool, and this use case covers them all: the user picks one and its settings on the setup console
(stage 1), then the photos, and every one is quoted before anything is charged. The stages below
are written for the comic book and apply to each of the others the same way, with that tool's
schema in place of `picsart_comic_create`'s (see "Each thing ComicMe makes" at the end). A poster
or a single picture is another use case: when the user wants one of those, start that use case
instead.

| Stage | Gate | Skills |
|---|---|---|
| 1. The setup, on the console | ASK | — |
| 2. The photos, as URLs | ASK | — |
| 3. The quote | SPEND | — |
| 4. Draw it | — | — |
| 5. Show it | SHOW | — |

## 1. The setup, on the console

A message asking to open Comic Setup again (the result panel's Open Comic Setup button sends one
after a creation) is this stage once more: open the console, with `heroImage` when the hero's photo
is already known, and treat its next lock as a new setup.

**`picsart_comic_setup` comes first**, before the photos and before a word of story. The console is
the ASK for everything at once: what to make, a comic (`picsart_comic_create`), a tale
(`picsart_comic_create_tale`), a video comic or a video tale (`picsart_comic_create_video`, by its
`style`), a reel (`picsart_comic_create_reel`) or an anime series (`picsart_comic_create_series`),
and that creation's settings: for the comic the genre (`genre`), the art style (`artStyle`), the
tone (`tone`), the premise (`premise`) and how many pages (`pageCount`); for the others their own
look and length, and for a series its story idea (`storyIdea`). It offers the values the Picsart app
offers, every one a value the tool's schema accepts, with the defaults chosen, so no value is
written here. One panel, one lock: never a question in the chat for what the console asks. Read the
request before you open it (the `picsart-video-rules` skill's Asking): most say the hero and the
mood in one line ("make me a horror comic").

- Pass `creation` when the words name what to make ("make me a reel"), and what they decide as
  `suggested.selections` under the tool's own input names, one `suggested.why` line each: the
  genre the words name, the pages when they said a number, a series' story idea when they told
  one, and the language (`language`) they wrote in when it is not English. Pass only what the
  words decide; the console's defaults stand otherwise.
- Pass the hero's photo as `heroImage` when its URL is already known (stage 2), so the console
  shows it. Open the console in full screen where the host supports it.
- The console is the ASK. On `comic_setup_feedback` (`verdict: "locked"`), its `tool` is the one
  to call and its `selections` go to that tool unchanged, with `language` when present; its
  `estimatedCredits` is the cost the console showed next to the lock, for stage 3. That
  lock is the setup's lock; to change it

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

Referenced files: 1 — file references are metadata, not package contents.

make-screen-videos30.6 KB

View saved version →

---
name: make-screen-videos
description: Turn a screen recording of an app or site into videos - standalone how-to shorts for Reels, TikTok or Shorts each teaching one easy thing, a feature explainer, a promo with each request typed over its result, a long session's timelapse, or a step-by-step 16:9 tutorial with chapters - in a style picked by eye, with a voice-over and captions if wanted. Use when the user has a screen recording and wants a tutorial video (for a help center too), a how-to, a reel, a short, a promo, a walkthrough or a demo video from it, or carries on with videos already planned from one, including a generated shot. Not for camera footage or a text-only article.
metadata:
  uses: screen-recording-analysis, footage-analysis, speech-aware-cutting, screen-recording-layouts, screen-recording-zoom, visual-style, screen-ui-redesign, retention-hooks, scene-building-basics, quality-review, ai-presenter, voice-over-generation, spoken-captions, background-music, motion-design-craft, film-shot-generation
  optional: ai-presenter, voice-over-generation, speech-aware-cutting, spoken-captions, background-music, motion-design-craft, film-shot-generation
  imports: screen-recording-analysis, screen-recording-layouts, screen-recording-zoom, visual-style
  title: Make screen videos
  short-description: Turn a screen recording into how-to videos
  argument-hint: '[screen recording and the video you want]'
  starter-prompt: Turn my screen recording into short how-to videos.
---

# Screen video

A screen recording is mostly waiting, and what it shows is a few pixels of dense UI. The same
recording can become very different videos: a set of 20-second shorts that each show how easy one
thing is, a promo that sells, or a tutorial that keeps every step. Which one is the user's to say,
so this use case starts with a short interview, never with a draft to approve.

The kinds, each a route in `references/routes.md`:

| Kind | For | Frame | Built by |
|---|---|---|---|
| **How-to short** | one easy task, start to result: "look how easy" | 9:16 | `scripts/promo_scene.py` |
| **Feature explainer** | one feature: the problem, the feature, two or three uses | 9:16 or 16:9 | `scripts/promo_scene.py` |
| **Promo** | the best results, fast, to sell; a timelapse for a long session; a re-cut for an edited video | 9:16 | `scripts/promo_scene.py` |
| **Tutorial** | every step in order, held long enough to follow, with chapters | 16:9 | `scripts/tutorial_scene.py` |

Read picsart-video-rules first: how to talk and how to ask are there, and every question here follows its
Asking rules. One job: one or more screen recordings in; one video, or a set of standalone videos,
out.

Before acting on a stage, load the skills in its row that apply to this job, also when the work resumes there.
A gate with a scope in brackets opens only there: `SPEND (vertical)` is the cold watch's go-ahead,
for a vertical video's draft alone; a horizontal video goes straight on through stage 10.

| Stage | Gate | Skills |
|---|---|---|
| 1. Take the recording in | — | — |
| 2. The interview | ASK | — |
| 3. Read the recording | — | screen-recording-analysis, footage-analysis |
| 4. The set: which videos | SHOW, ASK | screen-recording-analysis, screen-recording-layouts |
| 5. How we iterate | ASK | — |
| 6. The style | SHOW, ASK | visual-style, screen-recording-layouts |
| 7. The plan of video 1 | ASK | retention-hooks, quality-review, film-shot-generation |
| 8. The voice, when chosen | ASK, SPEND | voice-over-generation, speech-aware-cutting, spoken-captions, ai-presenter |
| 9. Build | — | screen-recording-layouts, screen-recording-zoom, scene-building-basics, visual-style, screen-ui-redesign, motion-design-craft |
| 10. Check it | SPEND (vertical) | quality-review, visual-style, screen-recording-zoom, screen-recording-layouts |
| 11. The user reviews | REVIEW | — |
| 12. The rest of the set | SPEND, REVIEW | retention-hooks, quality-review, voice-over-generation, screen-re

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

Referenced files: 34 — file references are metadata, not package contents.

make-short-drama33 KB

View saved version →

---
name: make-short-drama
description: Make a vertical drama series, pilot or episode with a recurring cast. Use for a short drama, a story reel, microdrama, web series or its next episode. Not for a one-off film (movie-producer).
metadata:
  uses: drama-series-writing, film-story-writing, film-cast-design, film-shot-generation, film-animatic, film-cutting, film-finishing, footage-reframing, retention-hooks, spoken-captions, background-music, scene-building-basics, quality-review, realistic-color-grade, voice-over-generation
  optional: realistic-color-grade, voice-over-generation
  title: Make a short drama
  short-description: Make a vertical drama series with a recurring cast
  argument-hint: '[series idea or the next episode]'
  starter-prompt: Make a short drama series from my idea.
---

# Make a short drama

Read picsart-video-rules first. Keep one visual world, one series Library and one accepted story
ledger. Decide on text, stills and sound before buying video: the user watches each episode as a
voiced animatic, and says yes to it, before its first take is bought. A generated episode is a candidate until
the user accepts it.

Before acting on a stage, load the skills in its row that apply to this job, also when the work resumes there.

| Stage | Gate | Skills |
|---|---|---|
| 1. The brief | ASK | — |
| 2. The series bible | ASK | drama-series-writing |
| 3. The look | ASK | film-story-writing |
| 4. Cast, places and props | SPEND, ASK | film-cast-design |
| 5a. Episode outline, script and model | ASK | drama-series-writing, film-story-writing, retention-hooks, film-shot-generation |
| 5b. The shot list | ASK | film-story-writing, film-shot-generation |
| 5c. Storyboard and animatic | SPEND, ASK, REVIEW | film-animatic, film-shot-generation, film-cast-design, voice-over-generation, scene-building-basics, quality-review |
| 5d. Shooting | ASK, SPEND | voice-over-generation, film-shot-generation |
| 5e. The cut, once the last take lands | SPEND, REVIEW | film-cutting, scene-building-basics, quality-review |
| 5f. Finishing, once per series | ASK, SPEND | spoken-captions, background-music, realistic-color-grade |
| 6. Verdict | — | quality-review |
| 7. Deliver and accept | ASK, DELIVER | film-finishing, footage-reframing |

| File | Read it before you… |
|---|---|
| `references/series-record.md` | create, update or resume the series record |

## Route and resume

| Request | Route |
|---|---|
| One-off short film | movie-producer |
| One clip | Offer one generation via `picsart_model_choose`, then SPEND (quote it in one line, then get the yes as an ASK with "Yes, go ahead" / "Yes, up to N credits for this task" / "No": the host's own choice tool where it offers one, otherwise those options numbered in one message; the host's own confirmation before a tool runs is not this yes; unless a spend limit the user stated covers it: N credits or an explicit no-limit ("as much as needed"), never inferred from words like "go ahead". Within it, ask nothing: quote it in one line ("About 8 credits; 12 of 20 left after this"), call it, then say what it spent and what remains, keeping a running total that includes failed calls, and stop to ask before the first call that would cross it. A money amount is asked once to restate it in credits; in unattended pace, never ask: call only with a consent or a stated spend limit already recorded, otherwise write the quote to pendingSpends and stop, as picsart-video-rules says) and `picsart_generate` |
| Series, pilot, sitcom or drama episode | This use case |
| Series record present | Read it, call `picsart_film_list_assets` with its `projectFolderUid`, say where the series stands, continue at the next episode |

An unfinished proposed episode resumes at its recorded stage before another is started. Restore
the accepted ledger and current asset versions first. Do not reset people to the original premise.
Take supplied state as fact; ask only for missing facts needed by the next step. A writing-o

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

Referenced files: 2 — file references are metadata, not package contents.

motion64.7 KB

View saved version →

---
name: motion
description: Turn static material into a real motion-designed video — a Figma design's LAYERS, or the user's own uploaded assets (photos, logos, screenshots, clips), become a composed, animated ad/reel where elements slide, scroll, type on, parallax, and smart-animate, tuned by eye, then rendered. The user can describe the motion they want, or let the skill analyze the assets and propose a concept. Use when the user wants to animate a design or assets, "make an ad/reel/video from these images/frames/screens", add motion to a Figma flow, or bring static material to life. Not for stitching footage the user already edited, and not for generating footage from a pure text idea (that's text-to-video).
---

# ChatGPT and Codex integration

Apply these host conventions throughout this skill and its references.

- Discover the connected Picsart tools and use their actual names and schemas.
  The `picsart_*` names in the workflow identify tools, not a fixed host namespace.
  If the connection is missing, explain that Picsart must be connected; continue
  script and shot planning when possible. Never invent tool results or renders.
- Read board decisions from the current user message and attached widget context.
  Use `read_widget_context` only if the host actually exposes that tool. Do not
  assume ChatGPT has Claude's context reader. Treat a board's initial tool result
  and unsent widget state as previews, never as user approval. If a submitted
  decision has no accessible payload, explain briefly and use the text fallback
  to collect the missing decision; do not guess or repeat charged operations.
- Use the host's available question interface or one concise conversational
  question for preset choices.
- UI rendering and delivery of feedback are the remote MCP server's responsibility.
  If a board is unavailable, present its relevant options in text and record the
  user's selection using the same documented feedback fields. Do not claim that
  a plugin manifest makes Claude-specific widgets compatible with ChatGPT.
- Save `motion.json` and artifacts in the user's writable project workspace, not
  the installed plugin directory. If persistent file tools are unavailable,
  keep a structured project checkpoint in the conversation and provide it for
  download when the host supports files. Never claim a file was saved without
  confirmation from a file tool.
- Honor the user's current instructions and already authorized scope. Preserve
  quoted spend limits and production locks; do not infer authorization from a
  preview, a timeout, or a connection being installed. A timed-out charged call
  needs a status check before considering a retry.
- This package holds six film skills (`film`, `film-development`, `film-assets`, `film-scenes`, `film-edit`, `film-finishing`) and three motion skills (`motion`, `motion-import`, `motion-design`). Route between them directly.
- `motion-import` reads a design's layers through the Figma app's tools. If Figma is not connected in this host, use its flat-frame fallback and say so once.


### Motion server compatibility

These host conventions qualify tool and widget instructions below. Discover
live tool names and schemas before invoking the pipeline. A ZIP update changes
instructions; it does not deploy new server tools.

When `picsart_scene_editor` is available, it accepts `scene`, `title` and
`notes` and emits `scene_editor_feedback` v1. Accept without edits or comments
returns `verdict: "approved"`; Submit after edits or comments returns
`verdict: "needs_changes"`. Read the returned `document` when `edited` is true:
frame comments carry `instruction`, and timeline comments carry `text`, `start`
and `end`. Opening the editor is a preview, never approval. If the tool is
absent, use the preview and text-review fallback already described in this skill.

Dedicated import/gradient/tracking tools in the new workflow may require a
newer MCP deployment. Call them only when exposed. Use a docu

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

Referenced files: 15 — file references are metadata, not package contents.

motion-design23 KB

View saved version →

---
name: motion-design
description: Stage 3 of the motion pipeline — the craft of turning a composed, layered scene document into a real motion-designed ad. Choose motion per element by role (what scrolls, types on, pops, parallaxes), author matched-element smart-animate between frames, and review it by eye in the scene editor (`picsart_scene_editor`), pair by pair. Called by the `motion` skill.
---

# ChatGPT and Codex integration

Apply these host conventions throughout this skill and its references.

- Discover the connected Picsart tools and use their actual names and schemas.
  The `picsart_*` names in the workflow identify tools, not a fixed host namespace.
  If the connection is missing, explain that Picsart must be connected; continue
  script and shot planning when possible. Never invent tool results or renders.
- Read board decisions from the current user message and attached widget context.
  Use `read_widget_context` only if the host actually exposes that tool. Do not
  assume ChatGPT has Claude's context reader. Treat a board's initial tool result
  and unsent widget state as previews, never as user approval. If a submitted
  decision has no accessible payload, explain briefly and use the text fallback
  to collect the missing decision; do not guess or repeat charged operations.
- Use the host's available question interface or one concise conversational
  question for preset choices.
- UI rendering and delivery of feedback are the remote MCP server's responsibility.
  If a board is unavailable, present its relevant options in text and record the
  user's selection using the same documented feedback fields. Do not claim that
  a plugin manifest makes Claude-specific widgets compatible with ChatGPT.
- Save `motion.json` and artifacts in the user's writable project workspace, not
  the installed plugin directory. If persistent file tools are unavailable,
  keep a structured project checkpoint in the conversation and provide it for
  download when the host supports files. Never claim a file was saved without
  confirmation from a file tool.
- Honor the user's current instructions and already authorized scope. Preserve
  quoted spend limits and production locks; do not infer authorization from a
  preview, a timeout, or a connection being installed. A timed-out charged call
  needs a status check before considering a retry.
- This package holds six film skills (`film`, `film-development`, `film-assets`, `film-scenes`, `film-edit`, `film-finishing`) and three motion skills (`motion`, `motion-import`, `motion-design`). Route between them directly.
- `motion-import` reads a design's layers through the Figma app's tools. If Figma is not connected in this host, use its flat-frame fallback and say so once.


### Motion server compatibility

These host conventions qualify tool and widget instructions below. Discover
live tool names and schemas before invoking the pipeline. A ZIP update changes
instructions; it does not deploy new server tools.

When `picsart_scene_editor` is available, it accepts `scene`, `title` and
`notes` and emits `scene_editor_feedback` v1. Accept without edits or comments
returns `verdict: "approved"`; Submit after edits or comments returns
`verdict: "needs_changes"`. Read the returned `document` when `edited` is true:
frame comments carry `instruction`, and timeline comments carry `text`, `start`
and `end`. Opening the editor is a preview, never approval. If the tool is
absent, use the preview and text-review fallback already described in this skill.

Dedicated import/gradient/tracking tools in the new workflow may require a
newer MCP deployment. Call them only when exposed. Use a documented live
recipe or the source's explicit fallback when it supports the same operation;
otherwise explain the missing capability before proceeding with that step.
Keep the original editable assets and the current scene intact.

# Stage 3 — authoring the motion

A composed scene is a set of layered frames that render id

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

motion-design-craft23.6 KB

View saved version →

---
name: motion-design-craft
description: The craft of adding motion to any scene, whatever the video — an ad or reel, a promo, a tutorial or walkthrough, an explainer, an intro, outro or title card, or one beat inside a longer edit — motion chosen per element by its role, smart-animate and morphs between frames, transitions, strokes and mask reveals, reviewed by eye in the scene editor pair by pair. Use whenever motion is added to or changed in a scene — elements animating in or out, a transition that looks wrong, a morph, a mask, an animated callout, highlight or zoom, a logo reveal, kinetic text — including inside another use case or a tutorial, not only in the `animate-design` skill's pipeline, where it is stage 3.
metadata:
  owner: motion-designer
---

# Stage 3 — authoring the motion

A composed scene is a set of layered frames that render identical to the design and don't
move yet. This stage makes them move — and the gap between "slideshow" and "ad" lives
entirely in the choices made here: **which elements move, how, and what carries between
frames.** The design is authored as a scene throughout; every edit is a
`patch_scene` that writes a new scene document (`sceneRef` moves — always edit the latest).

The rule under everything: **motion draws the eye, so it is spent, not sprayed.** A frame
where everything animates at once reads as noise. Pick the focal element per beat, move
it, let the rest support.

## Motion in any scene, not only after an import

This craft is not limited to the `animate-design` pipeline. Use it wherever a scene gets motion: a
tutorial's full-screen moments and the transitions between its parts, a promo's title card, an
animated callout or highlight over a screen recording, a logo reveal, a presenter bubble that grows
into a full frame, a morph from one clip's framing into the next. Open this skill **as soon as the
motion is being designed**, not after a first transition already looks wrong. Everything below
applies; only the inputs differ:

- **"Frames" are the two states either side of the motion.** A is the last settled state before it,
  B the first settled state after it: two beats, two parts or two layouts of the same scene. Author
  A→B pair by pair, exactly as below.
- **No import, so tag the matched elements yourself.** An element present in both states (the same
  shape, logo, panel, bubble or recording) is matched. Diff the two states with
  `picsart_scene_diff_layouts`, passing those pairs as `matchHints`, or `picsart_scene_query_layout` on
  both, and read off the delta.
- **Shape changes, borders, masks, camera moves and sound sync** follow *Craft for any motion*
  below; read [`references/ENGINE-GOTCHAS.md`](references/ENGINE-GOTCHAS.md) before the first mask.
- **The motion lives in the scene that has the layers.** When the final video is a stitch of
  rendered parts, a rendered part can only cut or dissolve into the next. Author a transition that
  carries an element across the seam in the scene that still holds both sides as layers, before it
  is rendered.
- **Recorded footage stays footage.** Animate the layers around and over a recording (its panel,
  mask, frame, callouts and text); never re-time the recording itself to fit a motion.
- **Review still happens on the moving stretch**, in `picsart_scene_editor`, pair by pair. When
  another flow called this skill, that flow's review step is where the user approves.

## Read the design before animating it

**First, read what changed** — from tool facts, not by eye. Diff the pair with
`picsart_scene_diff_layouts` (pass frame A, frame B, and the import `matchKey`s as `matchHints`);
it classifies each layer as moved / resized / restyled / content-changed / entered / exited /
unchanged with root-space deltas. If the tool is unavailable, fall back to `picsart_scene_query_layout`
on A *and* B and diff by hand. Either way, **check fades yourself** — the diff sees only `visible`,
not numeric opacity, so an opacity change reads as unc

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

Referenced files: 17 — file references are metadata, not package contents.

motion-import22 KB

View saved version →

---
name: motion-import
description: Stage 1 of the motion pipeline — bring a design in as LAYERS, not flat frames. Pulls each Figma frame's layer tree (elements + transforms), captures each layer in its NATIVE format (live text, vector, or raster — PNG is a fallback, not the default), tags elements that recur across frames as matched, gets every asset onto a fetchable Picsart-hosted URL, and sets the video format (including output scale/sizes up front). Falls back to flat-frame ingest only when layers cannot be had. Called by the `motion` skill; not a standalone entry point.
---

# ChatGPT and Codex integration

Apply these host conventions throughout this skill and its references.

- Discover the connected Picsart tools and use their actual names and schemas.
  The `picsart_*` names in the workflow identify tools, not a fixed host namespace.
  If the connection is missing, explain that Picsart must be connected; continue
  script and shot planning when possible. Never invent tool results or renders.
- Read board decisions from the current user message and attached widget context.
  Use `read_widget_context` only if the host actually exposes that tool. Do not
  assume ChatGPT has Claude's context reader. Treat a board's initial tool result
  and unsent widget state as previews, never as user approval. If a submitted
  decision has no accessible payload, explain briefly and use the text fallback
  to collect the missing decision; do not guess or repeat charged operations.
- Use the host's available question interface or one concise conversational
  question for preset choices.
- UI rendering and delivery of feedback are the remote MCP server's responsibility.
  If a board is unavailable, present its relevant options in text and record the
  user's selection using the same documented feedback fields. Do not claim that
  a plugin manifest makes Claude-specific widgets compatible with ChatGPT.
- Save `motion.json` and artifacts in the user's writable project workspace, not
  the installed plugin directory. If persistent file tools are unavailable,
  keep a structured project checkpoint in the conversation and provide it for
  download when the host supports files. Never claim a file was saved without
  confirmation from a file tool.
- Honor the user's current instructions and already authorized scope. Preserve
  quoted spend limits and production locks; do not infer authorization from a
  preview, a timeout, or a connection being installed. A timed-out charged call
  needs a status check before considering a retry.
- This package holds six film skills (`film`, `film-development`, `film-assets`, `film-scenes`, `film-edit`, `film-finishing`) and three motion skills (`motion`, `motion-import`, `motion-design`). Route between them directly.
- `motion-import` reads a design's layers through the Figma app's tools. If Figma is not connected in this host, use its flat-frame fallback and say so once.


### Motion server compatibility

These host conventions qualify tool and widget instructions below. Discover
live tool names and schemas before invoking the pipeline. A ZIP update changes
instructions; it does not deploy new server tools.

When `picsart_scene_editor` is available, it accepts `scene`, `title` and
`notes` and emits `scene_editor_feedback` v1. Accept without edits or comments
returns `verdict: "approved"`; Submit after edits or comments returns
`verdict: "needs_changes"`. Read the returned `document` when `edited` is true:
frame comments carry `instruction`, and timeline comments carry `text`, `start`
and `end`. Opening the editor is a preview, never approval. If the tool is
absent, use the preview and text-review fallback already described in this skill.

Dedicated import/gradient/tracking tools in the new workflow may require a
newer MCP deployment. Call them only when exposed. Use a documented live
recipe or the source's explicit fallback when it supports the same operation;
otherwise explain the missing capability before p

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

motion-intent12.1 KB

View saved version →

---
name: motion-intent
description: Choose and diagnose scene motion from communication intent before selecting presets or keyframes. Use when a user says “make this motion feel…”, asks to choreograph a scene, choose timing/easing/stagger, establish motion hierarchy, or explain why an animation feels flat, noisy, robotic, sluggish, or unfinished.
metadata:
  category: authoring
  version: '1.2'
  ported-from: motion-intent 1.2 at 55.75.0
---

# Motion by intent

Choose motion from communication intent before choosing presets or keyframes. Motion spends
attention; an element should move because the beat needs it, not merely because it can.

This recipe uses three evidence labels:

- **scene fact** — behavior defined by the format, validator, resolver, or authoring tools.
- **Motion heuristic** — a useful starting rule that must be judged in the actual scene.
- **Project choice** — a local style decision that should stay consistent inside one piece.

Do not present a heuristic or project choice as something scene enforces. Exact starting values
below are trials, not universal constants.

## Decide in this order

1. **Communication goal** — what must the viewer understand or notice?
2. **Visual leader** — which one element owns the beat, and what stays subordinate?
3. **Spatial relationship** — reveal, replace, connect, emphasize, orient, or resolve.
4. **Timing and sequence** — what precedes, overlaps, follows, and holds?
5. **Motion character** — direct, soft, restrained, playful, urgent, or continuous.
6. **Settle and readable hold** — what must become still, and for how long?
7. **Evaluation** — did the result communicate the original goal without added competition?

Only after these decisions should an author choose scene properties, presets, or keyframes.
Concrete syntax is `picsart_scene_recipe scene-animation-reference`; reusable realizations are
`picsart_scene_recipe motion-pattern-library`. When the question spans consecutive beats or a scene boundary,
route the relationship and seam decision to `picsart_scene_recipe motion-scene-continuity`.

## 1. Communication goal

| Goal | Communication job | Possible scene realization |
|---|---|---|
| **Reveal** | introduce content | an entrance preset, text animation, or explicit opacity/transform track |
| **Conceal** | remove content | an exit preset or explicit opacity/transform track |
| **Replace** | make one state become another | keep shared layers continuous; remove and introduce only what changes |
| **Connect** | show a relationship or journey | position path, parenting, anchor and rotation, or a drawn path |
| **Emphasize** | redirect attention mid-beat | a restrained scale, position, rotation, focus, or colour change |
| **Orient** | communicate direction, order, or progress | coordinated position tracks or a catalog transition such as `slide`, `diagonal_slide` or `page_curl` |
| **Resolve** | show that an action reached its intended result | return to rest, reduce amplitude, then hold if comprehension needs it |
| **Atmosphere** | keep an otherwise static interval alive | low-amplitude continuous motion that never becomes the leader |

**Motion heuristic:** one verb is usually enough for one beat. If the goal needs “reveal, emphasize,
spin, and celebrate,” split it into beats or choose the one communication job that matters.

## 2. Visual leader

Name the leader before assigning motion. Supporting elements may prepare for it, follow it, or remain
still. A useful hierarchy trial is:

| Role | Starting treatment |
|---|---|
| leader | largest or clearest change in the beat |
| support | smaller change, later start, or fewer animated properties |
| ambient | slow, low-amplitude continuity, or no motion |

These are **motion heuristics**, not amplitude requirements. A leader can also win through isolation,
contrast, or timing while moving less than its support.

For repeated items, decide whether the group is one idea or a reading order. Move the group together
for one

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

Referenced files: 1 — file references are metadata, not package contents.

motion-pattern-library25.1 KB

View saved version →

---
name: motion-pattern-library
description: Worked scene motion patterns for entrances, exits, stagger, directional nudges, emphasis, ambient life, springs, arcs, layered beats, parenting, parallax, focus, wipes, drawn strokes, and cartoon fast motion (smears, multiples, speed lines). Use when the motion intent is known and you need supported scene properties and keyframe structures to adapt; values are starting points, not universal timing rules.
metadata:
  category: authoring
  version: '1.6'
  ported-from: motion-patterns 1.6 at 55.104.0
---

# Worked beats

Choose a construction for the intended beat, adapt it to the scene, then check the result.
The snippets are fragments, not complete scenes or ready-to-run MCP calls; `…` marks omitted input.
Times, distances and amplitudes are starting choices, not quality guarantees. Use `picsart_scene_validate`
for structure, `picsart_scene_query_layout` / `picsart_scene_lint_layout` for declared geometry, and `picsart_scene_contact_sheet` with explicit `times` and `resolution` equal to the composition dimensions
plus continuous playback to judge the motion. Fetch current preset/look parameters before applying one.

Before adapting **any pattern below**, read
[Validation by pattern](references/validation-by-pattern.md). Select its row, declare the intended
outcome and tolerance, and retain its measurement and visual checks in the beat's acceptance plan.
Fetch it through MCP with `picsart_scene_recipe` using `name: "motion-pattern-library"` and
`reference: "references/validation-by-pattern.md"`. A successful render or schema check alone is
not motion acceptance; report measured, visually inspected, and unchecked outcomes separately.

Decisions behind these — which beat, which register, how long — are
`picsart_scene_recipe motion-intent`. The fields themselves are
`picsart_scene_recipe scene-animation-reference`. For whole-sequence relationships, visual carriers, intentional
resets, and seam choice, start with `picsart_scene_recipe motion-scene-continuity`. This is the middle: shapes
that work.

## Entrance, and the exit that answers it

A useful pacing trial is an exit around 65–75% of its entrance. This is a motion heuristic, not an
scene rule. Pick the form by what happens next:
a **motion preset** when the keyframes will be edited afterwards (by the agent or in the editor), a
**look** when the motion should stay a named, swappable entry for the editor.

As a look, both halves are one look played at either end of the layer by `role`:

```json
{ "scene": …, "layerId": "card", "preset": "look:zoom", "params": { "role": "in",  "length": 0.5,  "scale": 0.9 } }
{ "scene": …, "layerId": "card", "preset": "look:zoom", "params": { "role": "out", "length": 0.35, "scale": 0.9 } }
```

Each call appends one `looks[]` entry, so the document keeps both by name and an editor can show and
swap them. `role: in` starts at the layer's start; `role: out` ends exactly at its end, however the
layer is later trimmed.

As motion presets, `picsart_scene_apply_preset` with `motionPreset:<id>` (iOS `applyMotionPreset`) expands each into ordinary
keyframes you then own:

```json
{ "scene": …, "layerId": "card", "preset": "motionPreset:zoom_in",  "params": { "duration": 0.5, "from": 0.9 } }
{ "scene": …, "layerId": "card", "preset": "motionPreset:zoom_out", "params": { "duration": 0.35, "to": 0.9 } }
```

Check start, midpoint and end bounds: the size should change around the intended pivot, with no
unintended center drift. Check the exit against the layer's actual end after trimming.

The motion looks at a glance, so a substitution is an informed one (`picsart_scene_capabilities`
`look:<id>` has every param):

| Look | What it does |
|---|---|
| `fade` (`in` / `out`) | opacity only; nothing moves |
| `slide` (`in` / `out`) | travels `distance` multiples of its own size along `direction`, `up` by default |
| `zoom` (`in` / `out`) | grows from, or shrinks to, `scale` of its own size |
| `spin` (`in` / `out`) 

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

Referenced files: 4 — file references are metadata, not package contents.

motion-review8.81 KB

View saved version →

---
name: motion-review
description: Review an existing scene for motion that is confusing, mistimed, distracting, broken at a seam, or unnecessarily expensive. Use when asked to critique or improve a finished animation, audit a multi-beat scene, prioritize motion fixes, or decide whether a static element should move, and before reporting that your own render, character, rig or acceptance video works.
metadata:
  category: workflow
  version: '1.0'
  ported-from: motion-review 1.0 at 55.128.2
---

# Review motion in an existing scene

Review the authored scene and the moving picture together. A valid document and a good still frame
cannot establish that a beat reads correctly in sequence. Find the few changes that would most
improve comprehension, then verify each change in the interval where it matters.

This recipe reviews an existing document. For a new beat, start with motion-intent (fetch with
`picsart_scene_recipe`, name `motion-intent`). For scene syntax and worked constructions, use
scene-animation-reference and motion-pattern-library, fetched the same way.

## Establish what the scene is trying to say

Read the brief, storyboard, reference, or editor notes when supplied. Without one, describe the
apparent message as an **inference** and avoid treating your preferred style as the intended one.

Make a short timeline map from the scene itself: composition duration and frame rate, layer
windows, track clips and transitions, motion tracks, looks, text animations, and nested
`scene_ref` content. Use `picsart_scene_inspect` for a large document; it shows authored values
and addresses, not evaluated root-time positions. Identify each visible beat's leader, the change
it should communicate, and the interval in which that change must be read. Mark every seam and
every long hold for closer inspection.

**Do not add motion simply because a layer is static.** Stillness may support reading, contrast, or
an intentional reset. A proposed addition needs a communication job and a viewer-visible change it
would clarify. Reject it when it only repeats another layer's gesture or competes with the leader.

## Gather evidence at the right scale

1. Run `picsart_scene_validate` on the document under review. Repair an invalid scene before
   judging subtle timing. A successful validation proves the document's contract, not the rendered
   beat.
2. Use `picsart_scene_query_layout` at the start, interior, landing, and hold of each suspect
   motion. Query both sides of a seam. Map nested or layer-local clocks to root time before
   comparing values. If there is an explicit geometric expectation, use
   `picsart_scene_check_contracts` over its intended window, and `picsart_scene_check_motion` for
   frame-complete motion expectations.
3. Use `picsart_scene_contact_sheet` with explicit `times` for decisive frames, including an
   interior frame rather than endpoints alone. Inspect pixels for visibility, crop, blur, text
   readability, and overlapping attention.
4. Watch the **continuous rendered interval** at its intended viewing speed when the issue is
   pacing, acceleration, causality, or a seam. Stills can suggest where to look but cannot settle
   those questions. If only stills are available, mark the temporal judgment unverified.

For reference matching, compare the reference and candidate over the same window using
`picsart_media_track_motion_diff`, `picsart_media_flow_diff`, or `picsart_media_inventory_diff` as
appropriate. These answer different questions: trajectory, flow, or visible inventory. None
judges whether an original motion choice is expressive.

## Diagnose before changing a value

Name the observed failure in scene terms, then identify the smallest responsible span or layer.

| Observation | First thing to inspect | Next decision |
|---|---|---|
| The viewer cannot tell what changed | leader, contrast, arrival order, hold | remove competing motion or reveal the needed result more clearly |
| A move feels abrupt or drifts a

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

motion-scene-continuity12.9 KB

View saved version →

---
name: motion-scene-continuity
description: Plan and diagnose continuity across scene beats and scene boundaries—semantic handoffs, dominant direction, shared visual carriers, causal action/reaction, intentional resets, and seam verification. Use when consecutive scenes feel like separate slides, a transition breaks momentum, a shared element must persist, or a multi-scene sequence needs a continuity review.
metadata:
  category: authoring
  version: '1.1'
  ported-from: motion-continuity 1.1 at 55.75.0
---

# Motion across beats and seams

Served checks: `picsart_scene_check_contracts` runs contract records and reusable templates, `picsart_scene_check_motion` runs frame-complete motion records, and `picsart_scene_inspect` pages large sources; the one remaining limit is that pixel records have no automated checker, so inspect full-resolution rendered frames for them.

This skill owns the relationship between consecutive beats or scenes. Use
`motion-intent` for the purpose and hierarchy inside one beat,
`scene-animation-reference` after the motion is decided and needs scene syntax, and
`custom-transitions` only when the current transition catalog cannot express an already-decided
seam.

Keep three kinds of statement separate:

- **scene fact** — behavior defined by the format, validator, resolver, or authoring tools.
- **Motion heuristic** — a useful continuity trial that must be judged in the actual sequence.
- **Project choice** — a local editorial or brand decision.

Direction, velocity matching, overlap, and holds are motion heuristics, not rules enforced by the scene format. A hard cut, crossfade, direction change, or moment of stillness can be exactly right when the
communication calls for interruption, ambiguity, atmosphere, punctuation, or a chapter reset.

## Decide each boundary in this order

### 1. Name the semantic relationship

Choose the verb before the mechanism:

| Relationship | What the viewer should understand |
|---|---|
| continuation | this is the same action, object, or journey carrying on |
| replacement | one state gives way to another |
| reveal | the previous beat causes or exposes new information |
| arrival | a subject or destination has been reached |
| interruption | a new event deliberately breaks the previous flow |
| reset | a chapter or idea has ended and a new one begins |

If the relationship is unclear, a transition name will not make it clear. State the intended
relationship in one sentence first.

### 2. Choose a contextual vector

For continuation, first try carrying the dominant travel direction or the apparent momentum through
the seam. For arrival or reset, reducing motion or changing direction may communicate the meaning
better. Reading direction, subject movement, layout, and camera logic all affect the choice; there is
no universal rule that right means progress or that matched velocity is always desirable.

Record the trial as a project decision, for example: “The card continues upward because the next
arrangement reveals content below it.” Do not describe the decision as a scene requirement.

### 3. Choose the representation

Use the smallest scene structure that preserves the intended relationship:

| Need | First scene representation |
|---|---|
| same object, new arrangement | keep one layer alive; animate its placement delta |
| whole-frame directional handoff | track transition from the current transition catalog |
| unsupported seam mechanism | custom transition definition, routed to `custom-transitions` |
| deliberate discontinuity | adjacent track clips with no transition |
| ambiguous/quiet replacement | crossfade when identity continuity is not the message |

**scene fact:** a track transition resolves the outgoing last frame and incoming first frame into
the transition's source and destination slots. It does not preserve arbitrary live animation from
the neighboring clips through the transition window. If live identity matters, prefer one persistent
layer or author

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

motion-tracking-from-video18.7 KB

View saved version →

---
name: motion-tracking-from-video
description: Measure what objects visibly do in a video - where each one moves, turns and grows, frame by frame - with picsart_media_track_motion, work out each move's easing (curve, overshoot, bounce) and turn it into scene keyframes; then measure your render the same way and compare them with picsart_media_track_motion_diff. Covers targets, estimators, tolerances, reading results, and placing tracked motion on a layer. Use when a scene must reproduce a reference video's motion, or a render's motion must be checked against one.
metadata:
  ported-from: motion-extraction unversioned at 55.75.0
---

# Motion extraction

`picsart_media_track_motion` recovers what objects **visibly do** in a flattened video: their
position, rotation and scale on every frame, fitted into scene keyframes. It does not recover the
keyframes someone authored. It produces new motion data that reproduces what is on screen.

Looking decides **what** to track. The tracker measures **where**, every frame, to a fraction of a
pixel. Never write a motion's numbers from a still or from memory: every timing and distance comes
from a tracking result. The end points are not enough: a move is matched when it **feels** the
same, so its easing (how it speeds up, slows down, overshoots and settles) is measured too, and
built from the numbers.

## Cost and receipts

Measure every required window with `picsart_media_track_motion` and
`picsart_media_track_motion_diff`, applying picsart-video-rules's SPEND rule to their billing
contracts. Each replies with a job receipt by default: follow it as picsart-video-rules says. Targets that share a tracking window go in one call, as many as
its `targets` schema allows: one `t0`/`t1` holds for every target, and each must be fully visible at
`t0`. A target that enters later, or is covered before `t1`, gets a call with its own window.

## The method

1. **Look at the first frame of the window** with `picsart_media_video_stills`, and choose what to
   track. On a flat background, `{ "auto": true, "max": 9 }` finds the distinct objects at `t0` and
   tracks each, ranked by how much they move. Objects that overlap merge into one, so give those a
   box each instead.
2. **Track.** `picsart_media_track_motion` with the video's `source`, the window `t0`/`t1` in video
   seconds, and `targets`: each one `bbox` (`[x, y, w, h]` at `t0`, in video pixels), `points`, or
   `auto`. Set `tolerance` for the source (below). For a card, photo or title, a `bbox` in
   `"mode": "similarity"` (position, scale and rotation); `"corners"` when it skews or tilts in 3D.
   Leave `fps` out, so it samples at the video's own rate, and run the window over the whole move:
   from the frame before it starts to the frame after it settles, so the easing and the settle are
   in the samples.
3. **Read the result before you trust it.** Per target it returns `animations` (the fitted
   keyframes with their easing, or an expression), `static` (the channels that did not move), `meta` with each
   channel's `maxError`, and `notes` on anything that weakened the track. `maxError` is the honest
   reconstruction error: a fit with a large one is an approximation, and you say so.
4. **Work out the easing** of each move from the dense samples (below).
5. **Place it on a layer** (below), as keyframes with `timeMode: "layer"`.
6. **Check it.** Export your render of the same window, track it with the same targets, and compare
   the two with `picsart_media_track_motion_diff` and their speed profiles (below).

## What the tracker cannot see

It measures where texture goes, frame to frame. Some changes have no texture to follow:

| Change | What to do instead |
|---|---|
| a reveal: a wipe, a mask growing | cropped stills of the box, one per frame of the reveal, for its edge; track whatever drives the reveal |
| a fade or a twinkle | stills either side and through it; the tracker has no alpha (below) |
| non-rigid motion: a flap, a bend, a wobb

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

Referenced files: 1 — file references are metadata, not package contents.

movie-producer35.5 KB

View saved version →

---
name: movie-producer
description: Make a short narrative film from a story, with recurring characters, one look and approved cast/location references, then draft video and a reviewed cut. Storyboard or animatic only on explicit request. Use for short films, movies, multi-scene scripts, or continuing an existing film (shot list, shot changes or next step). Load first; it brings in the film skills for each stage. Not for a drama series or its episodes (make-short-drama), a single clip, or footage the user already has.
metadata:
  uses: film-story-writing, film-cast-design, film-shot-generation, film-cutting, film-finishing, footage-reframing, background-music, scene-building-basics, quality-review, realistic-color-grade, sd25-pe, sd2-pe, film-animatic, voice-over-generation
  optional: realistic-color-grade, film-animatic, voice-over-generation
  title: Produce a short film
  short-description: Make a short film from your story, scene by scene
  argument-hint: '[story idea or script]'
  starter-prompt: Make a short film from my story.
---

# Short film

A film is not a long video. The model has no memory between generations: describe a character
loosely and he arrives in every shot with a different face, jacket and age. Everything here exists
to keep those people and places consistent. Lock the story, shot list, cast and location references,
then shoot draft video directly. The first moving draft the user reviews is the assembled cut.
Storyboard panels and an animatic are made only when the user explicitly requests them. They are
not part of the default flow, and are never offered as another decision before shooting.

Read picsart-video-rules first. One job: a story in, a short film out, with recurring people and places
and one look.

Before acting on a stage, load the skills in its row that apply to this job, also when the work resumes there.
`(preview-requested)` applies only to an explicit request for a storyboard or animatic;
`(animatic-requested)` only to an explicit animatic request. These skills and the preview REVIEW
are otherwise skipped; the location references are still prepared.

| Stage | Gate | Skills |
|---|---|---|
| 1. The idea | — | — |
| 2. The look | ASK | film-story-writing |
| 3. The story and the model | ASK | film-story-writing, film-shot-generation, sd2-pe, sd25-pe |
| 4. The shot list | ASK | film-story-writing, film-shot-generation |
| 5. Cast, places and props | SPEND, ASK, REVIEW (preview-requested) | film-cast-design, film-shot-generation, scene-building-basics, film-animatic (preview-requested), voice-over-generation (animatic-requested), quality-review (preview-requested) |
| 6. Shooting | SPEND, ASK | film-shot-generation |
| 7. The cut | SPEND, ASK, REVIEW | film-cutting, scene-building-basics, quality-review |
| 8. Finishing | SPEND, ASK, REVIEW | film-finishing, background-music, realistic-color-grade |
| 9. Deliver | ASK, DELIVER | film-finishing, footage-reframing |

Read these before you need them:

| File | Read it before you… |
|---|---|
| `references/stages.md` | say a stage is done, or open the next one |
| `references/board-replies.md` | act on a reply from any board |
| `references/project-record.md` | write or resume the project record |

## Before you start

**Route first.** The dividing line is recurring identity across scenes.

| The user brings | Route |
|---|---|
| One clip's worth of idea ("a boot stepping onto scree") | Not this use case. Say so, and offer one generation: `picsart_model_choose`, then SPEND (quote it in one line, then get the yes as an ASK with "Yes, go ahead" / "Yes, up to N credits for this task" / "No": the host's own choice tool where it offers one, otherwise those options numbered in one message; the host's own confirmation before a tool runs is not this yes; unless a spend limit the user stated covers it: N credits or an explicit no-limit ("as much as needed"), never inferred from words like "go ahead". Within it, ask nothing: quote it in one line ("A

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

Referenced files: 4 — file references are metadata, not package contents.

open-picsart-app1.21 KB

View saved version →

---
name: open-picsart-app
description: Open Picsart beside the conversation - the user's recent files, their Picsart Drive, the AI tools, and where to start a film or a motion design video - on a yes to one closed question. Use when a use case offers to open Picsart, such as during setup.
---

# Open Picsart

Picsart opens beside the conversation: the user's recent files, their Picsart Drive, the AI tools,
and where to start a film or a motion design video. It shows nothing until they say yes.

ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says): "1. Open Picsart" / "2. Not now".

- **On 1:** call `picsart_workspace_open` with `{}`. It takes no input and charges nothing. Say in
  one line what they can do there.
- **On 2:** go on with the use case.
- **The call fails:** say in one line that Picsart could not open right now, and go on. Never
  retry it in the same turn.
photo-slideshow12.4 KB

View saved version →

---
name: photo-slideshow
description: Build a photo promo or slideshow in a scene — probe the photos, sequence them as a track of clips with transitions, fill off-aspect photos with a blurred copy, add an animated title that stays readable over any photo, choose a font, and verify with a sweep of full-resolution frames. Use when asked for a photo slideshow, photo montage, photo reel, promo video from photos, Reels/Shorts/TikTok from pictures, or a titled sequence of images.
metadata:
  category: authoring
  version: '1'
  ported-from: photo-promo 1 at 55.75.0
---

# Photo promo / slideshow

Assumes the font asset from picsart_scene_fonts (a `live.fonts` entry), and that picsart_scene_patch returns the patched scene you pass to the next tool.

The most common scene job: N photos, one after another, a transition at each seam, a title.
Every value below was validated and rendered at 1080x1920; the whole scene is in
[the worked example](references/worked-example.md).

Related recipes: `picsart_scene_recipe scene-video-edits` owns the track, transition-window and
`blur_fill` detail; `picsart_scene_recipe motion-intent` chooses durations and easing.

## 1. Probe the photos

Call `picsart_media_probe` on every photo URL before authoring. Declare its `width` and `height` on the
asset. Those numbers decide which fit each photo gets (section 3), and they let `blur_fill` skip
its fill on a photo whose aspect already matches the composition.

```json
"p2": { "type": "image", "uri": "https://…/507090463024201.jpg", "width": 2494, "height": 2560 }
```

Compare each photo's aspect (w/h) with the composition's (1080/1920 = 0.5625). `cover` crops
the difference away: 2296x4080 (0.563) loses nothing visible, and a 2:3 portrait such as
2308x3462 (0.667) loses 16% of its width. A square or landscape photo such as 2494x2560 (0.974)
would lose 42% of its width, so it gets a blurred fill instead.

## 2. A track of clips with transitions

One `track` layer holds the photos as clips, back to back. Each seam that should not be a hard
cut gets one `transitions[]` entry keyed by `between`, the index of the gap (0 = between clips 0
and 1):

```json
{ "id": "reel", "start": 0, "duration": 12, "content": { "kind": "track",
  "clips": [
    { "id": "c1", "duration": 3, "content": { "kind": "media", "assetId": "p1", "fit": "cover" } },
    { "id": "c2", "duration": 3, "content": { "kind": "media", "assetId": "p2" },
      "looks": [{ "look": "blur_fill", "params": { "blur": 8, "resFactor": 10, "dim": 0.25 } }] },
    { "id": "c3", "duration": 3, "content": { "kind": "media", "assetId": "p3", "fit": "cover" } },
    { "id": "c4", "duration": 3, "content": { "kind": "media", "assetId": "p4", "fit": "cover" } }
  ],
  "transitions": [
    { "between": 0, "id": "crossfade", "duration": 0.6 },
    { "between": 1, "id": "slide", "duration": 0.6, "params": { "direction": "left" } },
    { "between": 2, "id": "crossfade", "duration": 0.6 }
  ] } }
```

- **Timing.** The track's `duration` is the sum of its clip durations (4 x 3 = 12). A transition
  does not shorten the reel. Its window is centred on the seam, so a 0.6s crossfade at the 3.0s
  seam runs from 2.7 to 3.3.
- **Duration rule.** Each window takes half its duration out of each clip beside it. The halves a
  clip gives up to both of its seams must fit inside that clip, or validation refuses the scene
  with `transition_window_exceeds_clip`. With 3s photos and 0.6s transitions, an inner photo
  still has 2.4s on its own.
- **Choosing a transition.** Read `picsart_scene_capabilities({ sections: ["transitions"] })`. A
  closed-set param lists its allowed `enum` values, and the validator refuses anything else. Keep one
  calm transition, `crossfade`, as the default, and spend a directional one (`slide`) on the seam
  that should read as "next". The rendered example's `slide` `direction: "left"` visibly moves
  through its window.
- **All seams the same?** `scene://montage` (`picsart_scene_capabilities`, sectio

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

Referenced files: 1 — file references are metadata, not package contents.

picsart-video-rules32.3 KB

View saved version →

---
name: picsart-video-rules
description: The rules every Picsart Video use case follows - how to talk to the user and ask, the five interactions (ASK, REVIEW, SHOW, SPEND, DELIVER), credit consent, asset URLs, when to preview and when to export, and the evaluation budget. Read it first, before any step of a use case.
---

# Picsart Video core

Every use case reads this first. It says how to talk to the user and how to spend their credits.
How this host performs each interaction is in `references/HOST.md`: read it before the first
interaction.

A use case's stage table names the skills each stage loads. Before you act on a stage, load the
skills in its row that apply to this job (a row may list alternatives, such as one per model),
also when the work resumes at that stage.

## Image generation and supplied photos

Every flow defaults to GPT Image 2.6 Sunburst (`gpt-image-2.6-sunburst`) for image generation: cast,
character sheets, scene pictures, keyframes, comics, replacements and standalone images.
Keep an explicit user model choice. Read `picsart_model_params` before setting parameters;
never silently switch image models for price, availability, references or a wide frame.
For an unsupported canvas ratio, generate at a supported ratio and use the existing framing/crop
workflow to fit the canvas, keeping the subject safe. If that cannot hold the composition,
ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says) for an explicit model or framing choice. Never send an unsupported ratio.

When the user supplies a photo of who or what to create, recreate or replace, use the actual
photo URL in `imageUrls`, not just its description. Save the supplied originals separately as
`identityReferences`: an array of URLs, `[]` only for an entirely generated identity, and absent
only for legacy unknown provenance. Carry these URLs into every later still, scene, shot,
regeneration and replacement depicting that identity. Generated sheets, cut views and opening
frames supplement the originals; they never silently replace them. A compiler's `usePhoto` or
`promptToken` does not attach pixels: check the actual generation arguments and each plan item's
`imageUrls`. Resolve unknown provenance from the supplied media before proceeding; never infer
that a generated sheet is the original. A model input limit is not permission to drop an original:
reduce optional references, split the run, or ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says) for a compatible model or framing choice.

## Tools

Tools are named here by their server names, such as `picsart_scene_export`. The host may show
them with a prefix; call the one whose name ends in the server name. Never name a tool to the user,
nor a model unless they asked about models. Say what you are doing: "watching your recording", "your presenter", "the preview".

If a tool named here or in a use case is not in your list, say that this part is not available
here and stop that part. Never substitute another tool.

**The user's computer, or the Picsart tools.** When the work is on the user's own computer (their
footage on its disk) and you can run commands there, use the software installed on it, such as
ffmpeg, python3 or Gyroflow. When something is not installed, ask before installing it, or skip
i

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

Referenced files: 2 — file references are metadata, not package contents.

plugin-version386 Bytes

View saved version →

---
name: plugin-version
description: Use when asked which Picsart plugin version or build is installed.
---

Package: picsart
Manifest name: app-6a18d4c190a0819186e6b129a09e931e
Manifest version: 2.5.0
Built at: 2026-11-10T14:56:03.599Z
Source revision: 24b3ba2
MCP server: https://api.picsart.com/gen-ai/mcp

Answer the user's question with these values; do not call any tool for it.
quality-review13.2 KB

View saved version →

---
name: quality-review
description: Check work before the user sees it - a scene validated, linted and looked at in contact-sheet frames, then fixed and checked again; a draft watched cold by model viewers against its viewer track, then reviewed by critics; the brief graded; an export checked against its scene. Use after a script is written and before it is built or paid for, after building or changing a scene, before REVIEW or an export, before handing over an export, and at each decision a use case names.
metadata:
  imports: screen-recording-layouts
---

# Evaluate

1. **Validate.** A successful `picsart_scene_patch` has already validated its result, so call
   `picsart_scene_validate` only after changes made any other way. Zero errors; fix the
   warnings too.
2. **Lint the layout.** `picsart_scene_lint_layout` over the timeline; on a long scene, narrow
   `t0`/`t1` to the part in question. Each of its `findings` is a sustained overlap between layers
   that should not touch. For a pair placed together on purpose, pass `allow: ["idA:idB"]`. A text
   box is the font's line box, so a clean lint is not proof and it can flag empty space. If the tool is not in your list, or fails because the
   query build is unavailable, skip to the frames.
3. **Measure.** For a flagged pair, or a use-case question about where something sits (inside a
   panel, inside a mask), `picsart_scene_query_layout` at that moment gives each layer's box. It
   reads layer geometry, not painted pixels.
4. `picsart_scene_contact_sheet` at each moment the use case names. Look at every frame and answer
   the use case's questions about it.
5. `picsart_scene_contact_sheet` once across the whole timeline — order, seams, nothing blank.
   Then, for every cut, its `times` at the cut and one frame either side (`cut − 1/fps`, `cut`,
   `cut + 1/fps`): a one-frame black gap falls between evenly spaced samples.
6. **Polish**, once the frames are right. A correct video can still look machine-made, and the
   user notices that first:
   - when the use case built it in a style, run the visual-style skill's `adherence.py` on it,
     and check the frames against that skill's list of defaults that look machine-made;
   - **the first frame is a real moment**: the payoff, or the problem it solves, as the
     retention-hooks skill's hook rules say. Not a login screen, an empty app or a title on a plain
     canvas;
   - **every second has something new**: no stretch over 3 s where nothing moves, appears or
     changes, unless it is a hold the use case asked for. First run `scripts/timing.py` on
     `{ scene }`, from this skill's folder: from the JSON alone it flags every stretch over 8 s
     with no change (`dead_air`), every block of words held under 0.3 s a word or 1 s
     (`short_hold`), and every block over 10 words, or a step label over 6 (`too_many_words`).
     Typed holds add only the typing remaining in each visible span, including after retiming or
     trimming. Text and caption masks in `mask.clip` or legacy `mask.layer` need rendered review;
     the script rejects them.
     Pass the measured reveals inside a clip as `changes`; the JSON cannot see them. Then look
     at the frames for the 3 s: motion inside a clip is only on them;
   - **not one move everywhere**: when every beat has the same push or the same entrance, vary
     what the use case's skills allow;
   - **words inside the safe zone** of the destination the use case names: run the screen-recording-layouts skill's
     `safe_zone.py` with its profile, and fix each finding. Readable at the frame's width.

   Fix each finding, or keep it and say why in the review line ("the app itself is navy, so the
   canvas follows it").
7. Fix the layers and check again. Building is free.

**The brief, item by item.** When the use case has a brief (the message, the destinations, the
length, the hook, the call to action, the steps), grade the build against it one item at a time,
never as one judgement of 

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

Referenced files: 30 — file references are metadata, not package contents.

quick-merge-and-export5.57 KB

View saved version →

---
name: quick-merge-and-export
description: The shortest path from media URLs to a rendered file - merge or concatenate several videos into one with the montage template, sample frames from a scene into a contact sheet, and export any valid scene to a file. Use when asked to merge, join or concatenate clips, to preview a scene as frames, or to render a scene, and no other skill covers the job.
metadata:
  category: authoring
  version: '1'
---

# Scene quickstart

Three short jobs, each a fixed chain of tools. Every tool takes media by URL. None reads a local
path, a `file://` URI or inlined file bytes, and such a source is refused before anything renders.
For a file the user has only on their device, call `picsart_drive_upload_ask`: it opens a
drag-and-drop upload. The call itself returns no URL; the file's URL arrives on the user's next
turn, as widget context (or in their message), so read it there before going on. Pass `detected_files` when you can see the file
name, and `known_urls` to offer URLs already made in this conversation.

## Merge several videos into one

The montage template plays its clips one after another and renders one file.

1. **Probe each clip.** Call `picsart_media_probe` once per clip URL for its width, height
   and duration. Skip a clip whose exact size and duration an earlier tool result already gave. A
   missing `durationSeconds` means the duration is unknown, not zero: follow the probe's own note
   on that field.
2. **Build the parameters.** Write the clips as JSON, one object per clip with `uri`, `width`,
   `height`, `duration` from the probe, and optionally `in` and `out` (the trim, in seconds),
   `fit` (`cover`, `contain` or `fill`) and `align` (one of nine positions such as `top left` or `center`, the default).
   Then run `scripts/montage_params.py`:

   ```bash
   python3 scripts/montage_params.py --transition crossfade --transition-duration 0.4 clips.json
   ```

   It prints the complete `picsart_scene_apply_template` arguments: `uri:
   "scene://montage"`, `mode: "bootstrap"`, and `parameters` with `transition`,
   `transitionDuration` and `clips`. Omit `--width` and `--height`: the canvas matches the largest
   clip and the frame rate follows the clips. Pass both only to deliberately change the aspect
   or size. For a smaller output file, use `picsart_scene_export`'s `resolution`. Pass
   `--transition ""` for a hard cut. Use `fit` and `align` when a clip's shape differs from the
   output's, as with portrait and landscape clips in one montage.

   **Without a shell, write the script's output yourself.** The template's clips do not take the
   input shape above. Each clip becomes `duration` (`out` minus `in`) plus a `content` object
   that carries the probed asset, the trim, `fit` and `align`. A hard cut is `transition: ""` with
   `transitionDuration: 0`. Here clip 1 is trimmed to 0–4 s of a 12 s clip, then a hard cut to
   all 8 s of clip 2:

   ```json
   {"uri": "scene://montage", "mode": "bootstrap", "parameters": {
     "transition": "", "transitionDuration": 0,
     "clips": [
       {"duration": 4, "content": {"kind": "media",
         "asset": {"type": "video", "uri": "https://…/a.mp4", "width": 1080, "height": 1920, "duration": 12},
         "trim": {"in": 0, "out": 4}, "fit": "cover", "align": "center"}},
       {"duration": 8, "content": {"kind": "media",
         "asset": {"type": "video", "uri": "https://…/b.mp4", "width": 1080, "height": 1920, "duration": 8},
         "trim": {"in": 0, "out": 8}, "fit": "cover", "align": "center"}}]}}
   ```
3. **Bootstrap the scene.** Call `picsart_scene_apply_template` with those arguments,
   unchanged. These arguments are complete, so this job needs no schema or template lookup. The
   composition's duration is the sum of the clip durations: never set it by hand.
4. **Validate.** Call `picsart_scene_validate` on the returned `scene`.
5. **Render.** Call `picsart_scene_export` with the scene and `mediaType: "mp4"`. It replies w

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

Referenced files: 1 — file references are metadata, not package contents.

realistic-color-grade6.26 KB

View saved version →

---
name: realistic-color-grade
description: Make a video's colours look more realistic and natural with the ai_realism look — take the over-processed, plastic, AI-generated look off footage with a gentle grade, a shine correction on skin and light colour grain, and choose its values per video. Use when asked to make video colors more realistic, natural or camera-like, to make AI-generated footage look real, to take the glossy or plastic look off skin, or to add subtle grain for realism.
metadata:
  category: authoring
  version: '1.1'
  ported-from: color-realism 1.1 at 55.75.0
---

# Colour realism with `ai_realism`

`ai_realism` is the look for "make the colours more realistic". It runs the three passes an
editor does by hand on footage that looks too clean, too saturated or too glossy — typically
AI-generated video:

1. **A gentle grade over the whole frame** — contrast, highlights and saturation pulled down
   slightly, plus an optional white-balance nudge.
2. **A shine correction on skin** — the skin's own hue is sampled every frame inside the
   portrait segmenter's skin matte, only bright skin is keyed, and its saturation, lightness and
   contrast come down, so the plastic, over-lit look goes. White shirts and warm walls are left
   alone.
3. **Light colour grain over the whole frame**, as a camera sensor's.

Every pass is subtle on purpose. If the change is visible at a glance, it is too strong.

The footage decides the grain, not the wording: a request that names only the colours still gets
grain when the footage is perfectly smooth, as AI renders are, and none when it is already noisy
or the user asks for none. Say in your reply how much grain you added and why, and offer to remove
it.

## When it fits

- Generated or heavily processed footage: waxy or glossy skin, punchy saturation, crushed
  highlights, no noise at all.
- A request phrased as "more realistic", "more natural", "less AI", "like it was shot on a
  camera", "less plastic".

Not the tool for:

- **A stylised grade** ("cinematic", "vintage", "teal and orange"). Use a LUT grade effect or a
  look such as `duotone`; `picsart_scene_capabilities` lists them.
- **Footage that already looks natural.** The grade and the grain add little and can flatten it.
- **A fix for one colour only** (an over-saturated sky). Use `hsl_secondary` directly, keyed on
  that colour.

## Apply it

Put the look on the **media layer itself** (an image or video layer), in reference mode, with
the values chosen for this video:

```json
picsart_scene_apply_preset({
  "scene": ..., "layerId": "clip", "preset": "look:ai_realism", "mode": "reference",
  "params": { "strength": 1, "skin": 1, "grain": 0.06 }
})
```

Anything left out takes the look's default. `picsart_scene_capabilities({ sections: ["look:ai_realism"] })`
returns every parameter with its range.

## Choose the values for this video

Look at the footage first: `picsart_media_probe` for its resolution, and `picsart_scene_contact_sheet` with `times: [t1, t2, …]` and `resolution` set to the scene's `composition.width` and `composition.height` to see the colour cast, how much skin shine there is and
whether it already has noise.

| Parameter | Default | Change it when |
|---|---|---|
| `strength` | 1 | The grade: highlights and saturation down, contrast barely, so blacks stay deep. Lower (0.4–0.7) for footage that is already soft or low in contrast; 0 skips it. |
| `temperature` | 0 | Negative (to about -0.3) to cool an orange, over-warm render; positive to warm a cold, blue one. Applies even at `strength` 0. |
| `skin` | 1 | The shine correction: bright skin's lightness and saturation down, its texture kept. 1 for glossy AI skin, about 0.5 for a light touch, 0 when nobody is in frame or the skin is already matte. In a dark scene it reaches only the brightest skin, as it should. |
| `skinHue` | 20 | Rarely. The skin's hue is sampled every frame; this is only the fallback when too little skin is visible to sample. |
| `skinHueR

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

recast5.69 KB

View saved version →

---
name: recast
description: Put the user's own characters, people or things into a video of theirs with Recast - each picture replaces one person or thing in the video, and the motion, the place and the sound stay as filmed - on a board that checks the video, offers each video model with its price and makes the video itself. A character swap for an AI influencer, a mascot or a product placed into real footage. Use when the user has a video and wants someone or something in it replaced by their character, a photo or a product ("put my character in this clip", "replace the cup with my product", "swap me into this video"). Not for a new video from a prompt or a picture (generate-media), cutting their footage (edit-footage), or an animated ad rebuilt with new photos and text (recreate-video).
metadata:
  title: Recast
  short-description: Put your character or product into your own video
  argument-hint: '[your video, and who or what goes in]'
  starter-prompt: Put my character into my video.
---

# Recast

Read picsart-video-rules first. One job: one of the user's own videos, with people or things in it
replaced by the user's pictures. The Recast board checks the video, offers the video models with
the price, and makes the video itself. You bring it the video, the pictures and who is in the video,
then read what it made.

| Stage | Gate | Skills |
|---|---|---|
| 1. The video and the pictures | ASK | — |
| 2. Who is in the video | — | — |
| 3. The board | ASK, SPEND | — |
| 4. What it made | DELIVER | — |

## 1. The video and the pictures

Every file goes in as a Picsart-hosted URL, as picsart-video-rules's Asset URLs says. A video or a
picture a Picsart tool returned in this conversation is used as it is. Files on the user's disk go
up with `picsart_upload_local_files` when you have a shell. Otherwise
ASK with `picsart_drive_upload_ask` for all of them in one panel, in the first turn.

What goes in, at most 8 pictures, in the order the user named them:

- **A character they name:** find it with `picsart_film_list_assets`, with no `projectFolderUid` for
  a character made outside a film and with the film's for its cast. Pass its `portraitUrl` as `url`,
  its `name`, and `character: true`: the sheet's views are one character.
- **A photo or a product shot:** its URL, with a `name` when the user gave one.
- **A new place they asked for** in a picture: that picture with `role: "place"`.

The board's own What goes in step adds pictures from the user's images, characters and props, or
from their device, and its Place step adds a place from their images, so never hold the board for a
picture: open it with what you have. A picture
that does not exist yet (a new character, a product shot) is a job of its own: offer make-character
or generate-media in one sentence, and do it only on a yes.

The board checks the video's length, size and frame rate against each model and says which ones
take it, so read no limits here.

## 2. Who is in the video

Read the video's length with `picsart_media_probe`, then look at 4 to 6 moments spread over it with
`picsart_media_video_stills` (`times`, `labels: true`). Both are free. Look at the sheet as
picsart-video-rules's Asset URLs says.

Write `found` from what you saw: every person, the main one first, then the things that matter to
the action, at most 8. Each is a short lowercase label by how it looks, never by where it stands or
by a name: "the woman in the long dark coat", "the cup in her hand". The board offers these labels
as what each picture replaces. When the user said who or what a picture replaces, set its
`replaces` to the label that matches.

## 3. The board

ASK with `picsart_recast_setup`: `videoUrl`, `pictures`, `found`, and only what the user said:

- `sound`: `generated` when they want new sound, `none` for silence; leave it out to keep the
  video's own sound.
- `notes`: their own words for the run that the board has no control for ("keep her hat on, make
  the cup red"), and with th

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

Referenced files: 1 — file references are metadata, not package contents.

recreate-video9.17 KB

View saved version →

---
name: recreate-video
description: Rebuild a reference video as an editable animated scene that moves and looks like it - the same layout, the same timing, the same motion - measured from the video rather than eyeballed, with the user's own photos and text in place of the original's. Use when the user brings a video and wants one like it ("make a video like this one", "recreate this ad", "reuse my own ad", "copy this animation", "rebuild this promo with my product"), or carries on a recreation already under way. Not for editing or trimming the user's own footage, and not for a new video from a description alone.
metadata:
  uses: reference-fragment-matching, motion-tracking-from-video, asset-audit, motion-review, scene-building-basics, quality-review, background-music
  optional: asset-audit, motion-review, background-music
  title: Recreate a video
  short-description: Rebuild a reference video with your own photos and text
  argument-hint: '[reference video, your photos and text]'
  starter-prompt: Recreate this reference video with my own photos and text.
---

# Recreate a video

A reference video is flat pixels: nothing in it says how it was made. This use case measures it,
fragment by fragment, and rebuilds it as a scene the user can edit, with their own content. The
result reproduces what the viewer sees, not the original project.

Read picsart-video-rules first. One job: a reference video in, an editable scene that matches it out.
Measuring and checking go as reference-fragment-matching says, with no SPEND gate; the SPENDs here
are artwork or music you choose to generate.

Before acting on a stage, load the skills in its row that apply to this job, also when the work resumes there.

| Stage | Gate | Skills |
|---|---|---|
| 1. Take the reference in | ASK | — |
| 1b. Map the content to the reference's slots | ASK | — |
| 1c. Where the decorations come from | ASK, SPEND | — |
| 2. Read it and check the scope | — | reference-fragment-matching |
| 3. The fragment plan | ASK | reference-fragment-matching |
| 4. Measure each fragment | — | reference-fragment-matching, motion-tracking-from-video |
| 5. Build each fragment | — | reference-fragment-matching, asset-audit, scene-building-basics |
| 6. Check each fragment | — | reference-fragment-matching, motion-tracking-from-video, motion-review, quality-review |
| 7. Join the fragments and lay the sound | — | reference-fragment-matching, scene-building-basics, background-music |
| 8. The user reviews | REVIEW | — |
| 9. Deliver | DELIVER | — |

For generated replacements, follow picsart-video-rules's Image generation and supplied photos:
keep its image default or the user's explicit model, and pass the supplied original photo in
each replacement's actual `imageUrls`. Carry it through subsequent shots; a description or
generated character sheet alone is insufficient.

## 1. Take the reference in

ASK (with the host's own choice tool where it offers one, such as request_user_input in Codex's Plan mode, so the user taps an option; a Picsart board the step names asks there instead; only where neither works, the options numbered in one message, the recommended one first; in unattended pace, never ask: write it to the project record's openDecisions with the answer you assumed, as picsart-video-rules says) for what is missing, in one question, with every file in one upload panel, as picsart-video-rules
says (Asset URLs):

- **the reference video**;
- **which part**, when it is longer than the part they want: a start and end time;
- **their own content** for the places the reference shows photos, clips, logos or text. Without it,
  the scene gets plain stand-ins in each of those places: a colour box of the same size, and the text
  the reference shows. Never the reference's own pixels, as the reference-fragment-matching skill says;
- **whether the reference is theirs**: their own template, ad or video. It decides the sound (below)
  and where the decorations can come from (stage 1c).

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

Referenced files: 1 — file references are metadata, not package contents.

reel-structure16.6 KB

View saved version →

---
name: reel-structure
description: Read a reference reel's structure and format, never its content - its beats, shots, caption pattern, pace and bed into a structure sheet (or parse a written breakdown for free), its layout, captions, hook and end card into the record's format, with what the footage can match; fit the user's script to the beats, and report each beat as matched, changed, dropped or added, with the content rules checked. Use when a short should be built the way a reference reel is built or looks, including the user's own channel.
metadata:
  source: channel team breakdowns and tools/reuse_guard.py, commit 3f064f0
  local-scripts: pick_style.py, style_check.py, build_index.py
---

# Reel structure

A reference reel lends its **structure**: where its beats fall, how its shots and captions
work, how fast it talks, what sits under the voice. Its **content** stays its own. Nothing the
viewer can see or hear of the reference reaches the user's video: no words, no frames, no audio
or music. Only its pattern is copied.

The method has five steps: read the structure into a sheet, check the sheet with the user, read
the format and what the footage can match of it, map the user's script onto the beats, and report
what matched and what changed. A job with no script (cutting footage to a reference) stops after
the format.

**The user's own channel is different**: its format is the spec to reproduce, and its logo, end
card, fonts and copy are theirs (own-brand mode, `references/format.md`).

## 1. Read the structure

**A written breakdown is free.** When the user brings a beat-by-beat breakdown, parse it and skip
the read:

```
python3 scripts/sheet.py parse breakdown.md --out sheet.json
```

**A style from our library supplies its own breakdown.** When the user brought no reference and the use case
builds in a style, read `references/style-library.md` (how the one best-fitting style is picked
for the footage, how it becomes the sheet and the format with no read and no SPEND, and how it is
built) and `references/style-index.md` (one line per style); then open only the picked style's
file, `styles/<id>.md`, never the whole folder. For a Thanksgiving or Friendsgiving reel, also read
`references/skin-thanksgiving.md` (the full skin); never on other occasions.

**A reference video is read with the tools, and the read is required**: none of it is optional
when the user sends a reel to follow. Run each required analysis below. Use the tool's billing
contract and picsart-video-rules's SPEND rule: quote any charged call, then SPEND (quote it in one line, then get the yes as an ASK with "Yes, go ahead" / "Yes, up to N credits for this task" / "No": the host's own choice tool where it offers one, otherwise those options numbered in one message; the host's own confirmation before a tool runs is not this yes; unless a spend limit the user stated covers it: N credits or an explicit no-limit ("as much as needed"), never inferred from words like "go ahead". Within it, ask nothing: quote it in one line ("About 8 credits; 12 of 20 left after this"), call it, then say what it spent and what remains, keeping a running total that includes failed calls, and stop to ask before the first call that would cross it. A money amount is asked once to restate it in credits; in unattended pace, never ask: call only with a consent or a stated spend limit already recorded, otherwise write the quote to pendingSpends and stop, as picsart-video-rules says).
Follow each job receipt as picsart-video-rules says.

| Order | Tool | What it gives the sheet |
|---|---|---|
| 1 | `picsart_media_probe` | length, frame size, frame rate, and whether there is audio |
| 1 | `picsart_media_segment_shots` over the whole length | the shots: holds and transitions, each with the step to sample it at |
| 2 | `picsart_media_video_stills` | at least 8 frames per shot, and every transition at its suggested step, at 480 px wide or more (never 180 px tiles); crop sheets (`crop`) of

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

Referenced files: 130 — file references are metadata, not package contents.

reference-fragment-matching9.83 KB

View saved version →

---
name: reference-fragment-matching
description: Rebuild a reference video as a scene one fragment at a time - split the reference into spans where one arrangement holds, take a census of each, measure every beat, build it, then check it against the reference on motion and on appearance until it matches - and join the fragments without tearing their seams. Use when a scene must reproduce a reference clip, or when one part of a recreation does not match its reference. A whole recreation starts in recreate-video.
---

# Fragment matching

**This skill is a stage of the recreate-video use case.** Before you act on a recreation, new or
carried on at any stage, load recreate-video if it is not loaded: its flow says which stage you are
at, what the user has agreed, and what to ask next. Then come back here for the stage's work.

Two laws:

1. **Measure, don't guess.** Every invented motion or timing has been wrong on its first render.
   Numbers come from the reference's pixels, through the tools, never from imagination.
2. **One fragment at a time.** Split the timeline into fragments and match each one against the
   reference until it holds, then move on. Never tune the whole clip at once.

**What it can rebuild today: flat-background motion graphics** (app and product promos: cards,
bars, chips, chat, grids) **and illustrated templates** (photo or clip slots dressed with stickers,
doodles and cut-out shapes). Live action, kinetic typography, particles, 3D and character animation
are out of reach. Say so before building, rather than deliver a plausible-looking wrong recreation.

The tools here read only a hosted reference. Frames you grabbed yourself carry no reliable times, so
nothing is timed from them.

Read this before you need it:

| File | Read it before you… |
|---|---|
| `references/seams.md` | plan more than one fragment, or join fragments into one scene |

## The loop

1. **Split the reference.** `picsart_media_segment_shots` with the `source` and the window `t0`/`t1`
   returns fragments, each a `hold` (one arrangement holds still) or a `transition` (it changes),
   with a `suggestedStep`: how densely to look at it. Look at a still either side of every boundary
   with `picsart_media_video_stills`: merge a boundary where nothing visibly changes, split a slow
   change it missed. A transition is real content and needs the densest work, never a gap to skip.
   Name each fragment by what happens in it ("the hero card shrinks and docks onto the input bar",
   never "fragment 3"), and work them in timeline order.
2. **Take the census.** Stills of the fragment at its `suggestedStep`. List everything that is
   there, not only what moves: each element's box, its fill or accent colour, its text, its corner
   radius. Motion checks cannot see a missing icon, a wrong accent or absent text, and those are the
   differences people notice first. Per element, also record:
   - **how it changes**: a rigid move, video inside its box, a mask reveal, a fade or twinkle, a flap
     or bend, a small idle motion, or none;
   - **its first and last visible time**, read on stills either side, not guessed from the motion;
   - **what it is tied to**: the container it moves with, or the element that drives its reveal;
   - **the sound** it lands on, when one lands with it.
3. **Measure every beat** on its route (below) with the motion-tracking-from-video skill, and write the **measured beat table**
   before you build any motion: per beat, its start and end time, its start and end extent
   (position, scale, rotation), and the tracking result each number came from. A beat with no row is
   a beat you are about to guess. One agent measured a card's geometry on stills and invented its
   time: it built a 0.225 s, 15% shrink where the reference measures 1.40 s and 67%. The beat it
   tracked over time was the one it got right.
4. **Choose what carries each motion** before you write it. Elements that move because their
   container moves are one 

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

Referenced files: 1 — file references are metadata, not package contents.

remix-reel-structure15.3 KB

View saved version →

---
name: remix-reel-structure
description: Remix a reference reel, a talking head or a skit included - copy the reel's structure (beats and timing, shots, caption pattern, pace, sound bed) onto the user's own script or topic, never its words, faces, frames, audio or music; build it as slides, voice and video, and report what matched and what changed. Use for "copy this reel's structure" or "remix this reel with my script", from the video or a written breakdown. Not for rebuilding a reference's animation with the user's photos (recreate-video).
metadata:
  uses: reel-structure, footage-analysis, retention-hooks, film-cast-design, film-shot-generation, film-cutting, ai-presenter, voice-over-generation, spoken-captions, screen-recording-layouts, screen-recording-zoom, photo-slideshow, film-finishing, background-music, quality-review, scene-building-basics
  title: Remix a reel's structure
  short-description: Copy a reference reel's structure onto your own script
  argument-hint: '[reference] [script.md or topic]'
  starter-prompt: Copy this reel's structure onto my script, and show me what matched.
---

# Remix a reel's structure

A reference reel lends its **structure**; the user's video keeps its own **content**. The
structure and length come from the reference, the channel's look from the user's house style,
and the words, people and screens from the user's script. Nothing the viewer can see or hear of
the reference reaches the result.

Read picsart-video-rules first. The method (the read, the sheet, the mapping and the report) is
the reel-structure skill's; this use case decides, asks and builds.

| Stage | Gate | Skills |
|---|---|---|
| 1. Take in the reference, the script or topic, and the house style | ASK | — |
| 2. Read the structure, or parse a breakdown for free | SPEND | reel-structure, footage-analysis |
| 3. The structure sheet and the content rules | REVIEW | reel-structure |
| 4. Map the script onto the beats, with the matched/changed report | ASK | reel-structure, retention-hooks |
| 5. Route by format | — | below |
| 6. `slides`: a still per beat, captions in the reference's pattern and the house style, no sound | REVIEW | film-shot-generation, spoken-captions |
| 7. `voice`: locked voices, paced to the sheet's words per second | SPEND, REVIEW | voice-over-generation |
| 8. `video`: the format's shots, cut on the beats, allowed spans kept | SPEND, REVIEW | the route's skills, film-cutting, quality-review |
| 9. Finish: grade, the sound bed as the sheet says, loudness, cover | REVIEW | film-finishing, background-music |
| 10. Final report (matched, changed, checked) and deliver | DELIVER | reel-structure |

## Not recreate-video

Both start from a reference video, and share nothing else:

| | recreate-video | remix-reel-structure |
|---|---|---|
| Copies | layout, timing and motion, measured frame by frame | beats, shot grammar, caption and pacing pattern |
| Keeps from the reference | the arrangement, with the user's photos and text in its slots | nothing visible or audible |
| Makes | an editable animated scene | new footage: generated, filmed or screen, cut to the structure |
| Matches at | the pixel and the motion | the beat: its role, its length within 15 %, its shot type, its caption timing |

**A talking head or a live-action reel comes here, never to recreate-video**: it has no layout
to rebuild, only a structure to follow. An animated promo or app ad whose look the user wants with
their own content goes to recreate-video.

## The record

Keep the project record as picsart-video-rules says, named `remix-reel-structure.json`. It holds
the reference (its URL or the breakdown's path), the house style's path, the script's path, the
sheet, the mapping and the report, the route, each stage's approval, the locked cast and voices,
`allowed-spans.json` once the screen clips are placed, and `openDecisions`. A later request
(`slides`, `voice` or `video`, a fix) reads it and resumes at the next stage.

## Content 

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

Referenced files: 1 — file references are metadata, not package contents.

resting-frame-rules4.57 KB

View saved version →

---
name: resting-frame-rules
description: Keep every element whole or gone whenever motion stops - when an animation finishes, when an element appears without moving, and on the last frame, each photo, card or title sits fully inside its frame or fully outside it, never cut by the edge. How to build entrances, exits, scrolls and zooms so they land clean, and how to check a scene with the layout tool. Use when animating photos, cards, screenshots or text in a scene, and before a scene with motion goes to REVIEW.
---

# Rest framing

**When motion stops, every element is whole or gone.** At each moment an element comes to rest, it
sits fully inside its frame or fully outside it. A photo the edge cuts while it slides reads as
movement. The same cut once it has stopped reads as a mistake: a picture cropped by accident.

An element comes to rest:

- when its animation finishes, or pauses long enough to read as a stop;
- when it appears without moving;
- on the last frame, where the video stops on whatever is still moving.

The frame is the canvas, or the composition that holds the element, such as a panel.

## What does not count as cut

- **A full bleed.** An element that spans its frame on an axis, past both edges: a background
  larger than the canvas, a band across the full width.
- **A crop inside the element's own box.** A photo `fit: "cover"` in its box, a mask, a zoom inside
  a panel. That is framing, not the edge.
- **A cut the design makes on purpose.** A phone mockup the design cuts at the bottom, a carousel
  that shows the next card's edge as a hint. Keep it only when the design or the user asked for it.

While an element moves, the edge may cut it.

## Build it so it lands clean

1. **Entrances end inside.** Start fully outside the frame, at least the element's own size past
   the edge, or start inside with opacity or scale. The last keyframe puts the whole element
   inside, with a margin.
2. **Exits end outside.** The last keyframe puts the element fully past the edge, or at opacity 0.
   End the layer there.
3. **A scroll or a pan stops on whole items.** Move the parent of the row or list, never each item.
   It stops where every item is whole or gone: the frame's edges fall in the gaps between items.
   An item larger than the frame does not fit a scroll; make it smaller or a full bleed.
4. **A zoom ends inside.** A scale-up that would push the element past the edge either ends at a
   scale that fits, or moves into a panel so the zoom crops inside the element's own box.
5. **The video ends at rest.** Every element shown on the last frame has finished moving. Never
   end on an exit or an entrance halfway through: hold the final layout, or let the exit finish
   before the end.
6. **An element larger than its frame** is a full bleed on that axis, or it is scaled down to fit.

## Check it

After the motion is authored, and after each change to it:

1. **Find the rest moments in the scene.** For each layer: the time of the last keyframe of each
   move in its `animations` or `transforms`, its `start` when it appears without moving, and the
   last frame. With `timeMode: "layer"`, keyframe times count from the layer's `start`. A layer
   with a `parentId` moves with its parent, so it rests only when the parent does too. Several
   layers that settle together share one moment.
2. **Ask the layout tool at each moment.** Call `picsart_scene_query_layout` with the scene and
   that `time`. For each layer that has come to rest then, read `onCanvas`:
   - `full` or `off`: whole or gone, as it should be;
   - `partial`: the canvas cuts it. It is a full bleed only when its `box` passes both edges of
     an axis; otherwise it is a finding.

   A layer with `clippedBy` is cut by the composition that holds it: when its `clippedBox` is
   smaller than its `box` on one side, that is a finding too.
3. **Fix each finding** with `picsart_scene_patch`, on the keyframe that ends the move, or
   on `transform.position` when the lay

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

retention-hooks7.71 KB

View saved version →

---
name: retention-hooks
description: Keep a short video watched to the end with open loops - a hook that opens a question in the first seconds, an intensifier, a rehook at the middle and a payoff that closes them, whether the lines come from the user's footage or are written for a voice or the screen. Use when ordering the moments of a short cut from talking footage, or writing the lines a short puts on screen or in a voice.
---

# Story loops

Hook, body and payoff tell you where things go. They do not keep anyone watching. What keeps a
viewer is an **open loop**: a question the video has raised and not yet answered. A short holds as
long as one loop is open, and sags wherever none is.

A loop is two moments: the line that **opens** a question and the later one that **closes** it.
Never open a loop the video cannot close, and never close one before the next is open. A serial
episode's exit question follows drama-series-writing instead.

## The three loops

| Loop | Opens | Where | It works when |
|---|---|---|---|
| **Hook** | the first question: a result, a contrast, a problem, a claim the viewer wants proved | in the first 2 s | the viewer can say what they are waiting to find out |
| **Intensifier** | the same question, sharper: a stake, a number, a "and it gets stranger", the reason it is harder than it looks | before 15 s, and inside the first quarter of a short under 60 s | it builds on the hook's question instead of starting another |
| **Rehook** | a new question, just as the first ones start to fade | near the middle, from 35% to 60% of the length | it is new: a second problem, a twist, the part the viewer did not expect, never the hook said again |

The **payoff** closes the hook's loop, at or near the end. The rehook's loop closes before or with
it. The serial exit question above may remain open.

Scale them to the length:

- **Under 20 s:** the hook and the intensifier. There is no middle to sag; the payoff comes at once.
- **20–30 s:** all three when the material has a second question; otherwise the hook and the
  intensifier, and say so.
- **Over 30 s:** all three. Without a rehook the middle loses the viewer.

## Choosing them from footage

When the lines come from what people said (a reel, a short, highlights), the loops are chosen, not
written. From the pool of moments:

- **Hook:** the sentence that raises the question the rest answers: a surprising result, a strong
  claim, a problem said plainly. A moment the watch rated `hook` is a candidate; it must still open
  a question, not just sound strong.
- **Intensifier:** a sentence right after it that raises the stakes of the same question.
- **Rehook:** a sentence that turns: "but", "except", "what nobody tells you", a second problem.
  Place it at the middle even when the speaker said it earlier, as long as it stands on its own:
  a cold reader of the heard script says whether it does, not you (the speech-aware-cutting skill).
- **Payoff:** the sentence that answers the hook. **Never use the payoff as the hook**: it closes
  the loop before it opens. Lead with the question, end with the answer.

Clean sentence edges still come first. A loop never justifies a clip cut mid-sentence.

## Writing them

When the lines are written, for the screen or for a voice:

- **Hook:** show the result and hold back how it was made, so the rest of the video answers
  "how?".
- **Intensifier:** the first line after the hook makes the question sharper, with a stake.
- **Rehook:** the line nearest the middle opens what comes next instead of describing what was:
  the harder request, the step the viewer did not expect.
- **Payoff:** the last result answers the hook. The call to action comes after it, never instead.

The writing's own rules still hold: no hype words, nothing the footage does not show.

## The hook

The hook buys the next two seconds. A viewer stops for something they already feel, never for a
product. Four rules, each one checkable on the hook's frames and words

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

scene-3d-authoring18.9 KB

View saved version →

---
name: scene-3d-authoring
description: Build a 3D scene (a composition whose space is 3d) — models, camera, lighting presets, floor, groups and parenting, model parameters, 3D motion presets (drop_in, fly_in_arc, snap_settle, bounce, idle_bob, wiggle, turntable; camera orbit, dolly, push_in, crane, whip_pan) — then render and measure it. Use when making a product or toy showcase, a build-up sequence of parts, an object that builds itself and then moves (drives, walks, unfolds), a turntable, a 3D title or any 3D document, or when 3D motion lands wrong, sinks into the floor or fails to evaluate. Not for a 2D cartoon character, face or mascot (shapes and the cartoon rig templates, in character-rigging), nor for flat layers in depth (photo cards that flip, a camera orbiting cards or panels) — that is a 2D scene with layer depth and the composition camera, in scene-animation-reference.
metadata:
  category: authoring
  version: '1.1'
  ported-from: 3d-authoring 1.1 at 55.91.0
---

# 3D scenes — models, light, motion, render

A 3D scene is a scene whose composition says `space: "3d"`: metres, y up, rotations in
degrees about x then y then z (intrinsic). Its layers are objects (a `model`, a `media` or 2D-scene card,
a `scene_ref` group, or a `light`), it is seen through one camera, and it plays as a rendered video:
`picsart_scene_contact_sheet` and `picsart_scene_export` render it, whether the 3D scene is the document
itself or one a 2D scene plays through a `scene_ref`. **Ask `picsart_scene_capabilities` for
`schema:Composition3D` and `schema:Layer3D` before writing a field** — a 3D object refuses 2D placement
fields (`anchor`, `effects`, `looks`, `transforms`) by name.

Flat layers in depth are not a 3D scene. Photo cards that flip in, panels that fan out, a camera
that orbits them: keep the 2D scene and give its layers `z`/`rotationX`/`rotationY` under the
composition camera (`picsart_scene_recipe scene-animation-reference`, "Depth and the camera"). The catalog
entries that work that way are tagged `2.5d` (`flip_in`, `flip`, `tilt_3d`, and the camera moves
`orbit`, `dolly`, `push_in`).

Every asset a 3D scene names — a model, a picture, a video — is a public https URL. Build the
document inline and change it with `picsart_scene_patch`.

## Start from a frame, a camera and a light

```json
{ "version": "1.0",
  "composition": { "space": "3d", "width": 1920, "height": 1080, "fps": 30, "duration": 8,
    "camera": { "eye": [0, 0.75, 1.7], "target": [0, 0.08, -0.1], "shutterAngle": 180 },
    "motionBlurSampleCount": 8 },
  "assets": { "brick": { "type": "model", "uri": "https://cdn.example.com/brick.glb" } },
  "layers": [ { "id": "b1", "content": { "kind": "model", "assetId": "brick",
      "materials": { "*": { "baseColor": "#e3000b", "roughness": 0.35, "clearcoat": 0.6 } } },
    "transform": { "position": [0, 0, 0], "scale": [10, 10, 10] } } ] }
```

- **Camera.** `eye` is where it stands, `target` what it looks at, both in metres; `lens.fov`
  is vertical degrees (default 35). Frame the subject by moving the eye, not by scaling the
  subject. `shutterAngle` 180 with 8 samples is film motion blur for the whole frame.
- **Light.** Set `composition.lighting` (`schema:Composition3D`): a `preset` — `studio`, `dark`,
  `sky` or `white_room` — then tune any one light over it (`key`, `fill`, `rim`, `ambient`: a key's
  `intensity`, `color`, `direction`, `shadow.softness`). `background`, `environment` and `ground`
  finish the look: a warm paper sweep with a soft-shadowed key is `studio`; a low orange key from the
  side with a dusk-gradient `background` reads as sunset; near-black with a bright cool `rim` is dramatic.

- **Post effects.** `composition.effects` is the 3D scene's post stack: `glow`,
  `ambient_occlusion`, `depth_of_field`, `color_grade`, `vignette`, `film_grain`,
  `channel_shift`. Their params, ranges and units are the `space: "3d"` entries of
  `picsart_scene_capabilities` `effects` — `sections: ["effect:ambient_occl

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

Referenced files: 2 — file references are metadata, not package contents.

scene-animation-reference35.1 KB

View saved version →

---
name: scene-animation-reference
description: How a scene expresses motion — preset catalogs, layer animations and transform stacks, easing and spatial tangents, Lua expressions, shared path phase, text on a curved or closed path, named actions mixed on a placed scene, depth and the composition camera (2.5D, cards that flip or fan out in depth under an orbit, a 2D film camera's pan, push-in and parallax), motion blur, held drawings (animation on twos), transition firing, and parameter drivers that keep a character alive on their own (eyes looking around, blinks, breathing, hair and ears that follow through, a tail that settles, whiskers that wiggle), with a pointer to the walk, wave and jump cycles of a cartoon rig. Use when motion needs authoring or validation, a character or object should glance, blink, breathe or sway by itself, objects need editable path offsets, text must follow a baseline, a scene validates but renders wrong, or a preset is rejected for the content kind.
metadata:
  category: authoring
  version: '1.19'
  ported-from: motion-mechanics 1.19 at 55.128.2
---

# Saying motion in a scene

The decision — what a beat is for, how long, which register — is `picsart_scene_recipe motion-intent`.
This is the other half: how the format says it, and the places where the obvious spelling is the
wrong one. For the relationship across beats or the choice of seam mechanism, decide first with
`picsart_scene_recipe motion-scene-continuity`, then return here for syntax. For semantic grouping, container
growth and sibling reflow, first use `picsart_scene_recipe linked-element-motion`. A common placement owner
does not imply automatic layout. The constructions below need verification in the actual scene.

## Named actions on a placed scene

When a placed scene declares fixed motions in its root `actions` map (imported bone timelines,
parameter motions, authored cut-out poses), its `scene_ref` layer plays and mixes them through
`content.animation`: a list of entries with `action`, `trim`, `speed`, `loop`, `weight`, `start`,
`duration`, `fade`, `mode` (`replace` or `aggregate`) and `tier`. A catalog rig's motion presets
write `scene_ref.parameters` bindings instead; those are live controls, not actions. Layer
`animations` move the whole rig. Mixing, tiers, crossfades without a rest dip, step channels,
`blending: "pass_through"`, a complete walk→idle scene and every refusal are in
[named-actions.md](references/named-actions.md); the schema is `picsart_scene_capabilities` with
`sections: ["schema:ActionAnimation"]`.

## Two catalogs, two ways in

They look alike and are applied differently. Getting this wrong is the commonest first failure.

| | Motion looks | Motion presets | Text animations |
|---|---|---|---|
| What | entrance/exit (`role: in`/`out`) `fade`, `slide`, `zoom`, `spin`, `wipe`, `blur`, `flip`; entrance `pop`, `flash`; loops `float`, `sway`, `shake`, `pulse`, `glow_pulse`, `blink`, `rotate`, `clockwork`, `ken_burns` | entrances `fade_in`, `slide_in`, `zoom_in`, `scale_pop`, `spring`, `rotate_in`, `blur_in`, `flip_in`, `reveal_in`; exits `fade_out`, `slide_out`, `zoom_out`, `rotate_out`, `blur_out`, `reveal_out`; emphasis `tap_pulse`, `glow_pulse`, `shake`; atmosphere `ken_burns`, `breathe`, `float`, `sway`; paging `step_slide`; secondary motion `settle`, `wiggle` (also on a shape group with `item`); parameter drivers `follow_through`, `random_pulse`, `random_hold`, `cycle` (write a parameter, below) | `typewriter`, `fade_in_chars` (`grow` makes each letter grow in too), `slide_up_lines`, `flicker_chars` (+ ambient ones, below) |
| Applied with | `picsart_scene_apply_preset` with `look:<id>` (iOS `applyLook`) and `params` (`role`, `length`, …); a window `start`/`duration` is set on the `looks[]` entry with `picsart_scene_patch` | `picsart_scene_apply_preset` with `motionPreset:<id>` (iOS `applyMotionPreset`) | name it in `content.animations[]`, or bake an entrance with `picsart_scene_apply_preset` and `textAnimati

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

Referenced files: 8 — file references are metadata, not package contents.

scene-building-basics5.41 KB

View saved version →

---
name: scene-building-basics
description: Build and edit a scene with the scene tools - declaring media, audio and fonts as assets, layer trims, audio layers and transitions, reading the schema once before patching. Use whenever a use case composes or changes a scene document.
---

# Composing a scene

Read the scene schema once before your first edit (`picsart_scene_capabilities` with sections
`["schemaSummary"]`, then `["schema:<Name>"]` for each definition you need, never `["schema"]` whole), then build and change the scene with `picsart_scene_patch`. For a first scene,
the `quick-merge-and-export` recipe (`picsart_scene_recipe`) holds a working tool-call sequence to start
from.

## Media

A layer declares its file once in `assets` as `{ id, type: "video", uri: <url> }` and points at it
by id: `content: { kind: "media", assetId: "<id>", fit, trim }`. The scene document has no
`assetType` field and no `video` kind, and an `assetId` holding a URL is `unknown_asset_ref`. Keep
each layer's `trim` in its own source's seconds, with BOTH `in` and `out`. Skip dead ranges: trim
around them rather than speeding through them.

## Audio

Voice-over plays as `audio` layers (`content: { kind: "audio", assetId, trim: { in, out } }`), each
with its layer's `start` at the moment it is heard. A step's line starts 0.15 s after its panel
appears, so the picture lands first. Every `trim` needs BOTH `in` and `out`; a trim
with only `in` is a `missing_field` error. Mute a recording's own track (`muted: true` on its media
content) unless its sound is being kept. **If the scene schema ever lists no audio
layer, say so and stop** — do not export a silent video and do not invent a mix.

## Fonts

**Fonts are declared assets.** Declare the font once in `assets` (`{ id, type: "font", uri }`) and
reference that `id` as `font.family` in every text and caption style; a family name the scene does
not declare fails to resolve at export. If a font cannot be found or does not resolve, name it to
the user; never swap in another font without saying so.

**Name the weight in the face, not in `font.weight`.** `font.weight` renders only where the scene
is resolved natively; a runtime that draws a translated scene ignores it and draws the face
`font.family` names at its own weight (`validate_scene` warns `font_weight_no_op`). For bold text,
use a bold face, such as a catalog key like `acumin-pro-bold`, or a declared font asset of that
weight, and leave `weight` out.

**The face must draw every character.** A face that lacks a character draws nothing or a box in
its place, and no font tool says which scripts a face covers. For words in basic Latin, most faces
will do. For accents or another script (Cyrillic, Greek, Arabic, Devanagari, Chinese, Japanese,
Korean …), prefer a face whose name names that script, or search by the name of a family made for
it. Then prove it on the first frame that carries the rarest characters; if any is missing, pick
another face, build again, and tell the user which face you used.

## Overlays

**An overlay never blinks.** When a caption, a title or a sticker follows another in the same
place, start it where the last one ends, and never let an overlay's opacity drop to 0 for a frame
or two: a gap that short reads as a blink.

## Transitions

When a panel replaces the one before it, a hard cut is fine and keeps the energy; a soft seam
(`'crossfade'`, 0.3–0.5 s) suits a change of layout. Check the live catalog with
`picsart_scene_capabilities` (`sections: ["transitions"]`) before naming any other transition.

## Coordinates

A scene built by hand goes wrong first in its coordinates:
- **A shape layer inside a composition starts at that composition's centre.** Set its position to
  `[0, 0]` and draw the shape in the composition's own pixels, or it lands half a frame off.
- **A mask is in the pixels of the composition that holds its layer**, not the layer's own: draw it
  where it shows, never shifted by the layer's position, and it does 

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

scene-template-remix12.6 KB

View saved version →

---
name: scene-template-remix
description: Select, reuse and customize scene catalog items. Use when remixing scene templates, looks, motion presets, text animations, transitions, effects or caption decorations, replacing placeholder content with media, or joining an outside object to a template.
metadata:
  category: workflow
  version: '1.7'
  ported-from: template-customization 1.7 at 55.128.2
---

# Reuse and customize a catalog item

Served checks: `picsart_scene_check_contracts` runs contract records and reusable templates, `picsart_scene_check_motion` runs frame-complete motion records, and `picsart_scene_inspect` pages large sources; the one remaining limit is that pixel records have no automated checker, so inspect full-resolution rendered frames for them.

Keep the requested design; change the smallest unit that meets the brief. A rendered
demo proves one instance, not that every parameter combination works.

## Select the unit and editing mode

For a named template, describe that URI first. If the catalog vocabulary is unknown,
start with `picsart_scene_templates({facetsOnly:true})`: no template bodies or
descriptions, just the small vocabulary. Then call again with relevant filters and `detail:"full"` to read descriptions.
Its global `facets` lists the available categories, tags and reference policies, even
when no entries match. Narrow with exact filters, then compare candidate descriptions,
aspect and parameter surfaces with `picsart_scene_capabilities`, section `template:<uri>`:

- `category` is the primary purpose: `ui_widget` for UI elements, `infographic` for
  data/diagrams, `slide` for presentation layouts, `editorial` for editorial stories.
  Use the returned vocabulary for the other categories; do not invent category names.
- `tags` crosses categories (such as `photos`, `comparison` or `chat`). Every requested
  tag must match; filters combine with AND. An empty tag list means no tag restriction.
- `referencePolicy:"expand-only"` finds authored starting points for structural edits;
  `"reusable"` finds entries that allow catalog references. Omit it to consider both.
  This filter's `reusable` value means the entry omits the expand-only metadata flag.

For example, `picsart_scene_templates({category:"ui_widget",tags:["chat","input"],referencePolicy:"reusable",detail:"full"})`
finds a reusable chat input composition; `{category:"editorial",referencePolicy:"expand-only",detail:"full"}`
finds editable editorial starters. If no entry matches, remove the narrowest tag or
category and inspect facets; do not substitute an unrelated template just to get a result.
When two or more entries (or looks, presets, transitions) fit the brief and the choice
comes down to taste, build 2–6 of them on the user's content and let the user pick in
`picsart_scene_picker`, each card labelled in their terms; go on from the one they keep
and say which (picsart-video-rules, "A choice made by eye"). A technical fit (aspect,
supported modes, parameters) is yours to settle.
Read `supportedModes` before choosing an operation. An entry with
`referencePolicy:"expand-only"` is a complete authored scene starter, not a blank
scaffold or a live reusable reference. Use `bootstrap` for a new editable scene or
`inline` for an existing host; reference mode (including the default) is refused.
Zero parameters means edit the expanded layers, not invent bindings. A parameter declaration may carry `group`
(a heading an editor lists it under) and, on a vec2, `frame` (`"composition"` or `{layer}`: the value is a point in
that frame). Both are presentation only: a resolver ignores them and never moves the point. Once copied,
the scene is yours to edit, save, and reference locally like any other scene.
For effects on existing layers, list them with `picsart_scene_capabilities({sections:["effects"]})`, then read
the chosen one with `effect:<id>`.
The list tool uses metadata filters, not semantic search. If nothing fits, state the missing
behavior before au

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

Referenced files: 7 — file references are metadata, not package contents.

screen-recording-analysis11.4 KB

View saved version →

---
name: screen-recording-analysis
description: Read a screen recording from its pixels - its shape, cuts and sound, when and where the screen changes, how long the waits are, the steps with their results, every action of a click-through with scripts/actions.py, the stages of a long working session, the shots of an already edited video - then look only at small still sheets of the moments that matter, and find private data in the text read from them with scripts/private_text.py. Use when a use case needs to know what happens in a screen recording, and when, without a model watching the video.
metadata:
  imports: screen-recording-zoom
---

# Screen analysis

A screen recording is mostly waiting, and the story is in the few pixels that change. Comparing
frames finds them: when something happens, where on screen, how long each wait is, and where one
step ends and the next begins. That needs no model that sees, so it is fast and gives the same
answer every time. Vision is spent only on still sheets of the moments that matter: to read a
request, to check a result, to pick a hook, to name a stage.

| Tool | Gives | When |
|---|---|---|
| `picsart_media_screen_moments` | the recording's events, waits, boxes and proposed steps, as one JSON | once per recording, first |
| `picsart_media_video_stills` | one image of tiled stills at the times you name, optionally cropped | each time you need to see a moment |
| `picsart_media_screen_stages` | the moments that look least like each other, with their novelty | a long working session with no waits to cut |

All three take the recording's URL as a Picsart tool returned it (see
picsart-video-rules's Asset URLs).

## The moments

Call `picsart_media_screen_moments({ videoUrl })`. Leave `fps` and `width` at their defaults. It returns:

- **The input**, `input`: the recording's `width` and `height`, its `orientation` (`landscape`,
  `portrait` or `square`), whether it is already `edited` (hard cuts between shots rather than one
  screen changing), its `cutsPerMinute` and the `cuts` themselves in seconds, and `hasAudio`.
- **Events**, in time order. Each has a kind, a start, a settle time (the last change, after which
  the region holds still), the box where it changed and the core of the largest change, all in
  source pixels, and the mean brightness of that box when it settles.
  - `cut`: most of the frame changed at once, such as a new page or a new message.
  - `scroll`: the page moved.
  - `reveal`: something was drawn at once.
  - `progressive`: something was drawn over time, such as streamed text or a render.
- **Dead ranges**: `still` when nothing moves, `waiting` when only a spinner or a caret does.
- **The content box**, everything that ever changed, and **the work area**, where the changes keep
  coming (the canvas, the viewport, the chat column, without the menus around it).
- **Cuts per band**: cuts counted in horizontal bands. A split layout hides its cuts from a
  whole-frame count, because one half never changes.
- **Proposed steps.** A step opens at a cut or a page-wide change. The typing just before it is its
  lead-in, and its result is the largest change that follows. Each result has its box, its settle
  time and its subject: the textured part of the result's card, such as the photo and not the chat
  around it. A timelapse gets no proposed steps: its stages take their place.
- **A suggested tier**, `tier`: `prompt_over_result`, `timelapse` or `recut`, with the measurement
  behind it in `tierReason`.

**The proposed steps are a proposal, not a decision.** Keep, drop and reorder them after you have
looked at their stills. Never keep a step the stills do not show.

**The times are measured.** A settle time comes from the pixels, so a push timed to it lands on the
finished result. Never move it by a fixed offset ("the result is 2 s in"): reveal times vary by
seconds from step to step.

## Actions

When every step a recording shows counts, not only its results (a click-through 

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

Referenced files: 9 — file references are metadata, not package contents.

screen-recording-layouts12.4 KB

View saved version →

---
name: screen-recording-layouts
description: Lay a screen recording out in a 1080x1920 vertical frame or a 1920x1080 landscape one - the layout catalog (full frame, prompt over result, head and screen, screen with head bubble, results grid), recording panels, whether a moment's UI will read in its panel, and each destination's safe zone. Use when composing a vertical or a 16:9 video from screen footage, landscape, portrait or square.
---

# Layouts for a vertical frame

A desktop recording is landscape; the reel is 1080×1920. Do **not** cover-crop the whole screen and
zoom into it — at cover scale the UI is already enlarged, and any emphasis zoom on top reads as "too
much zoom". Instead, put the recording in a **panel** that frames the part of the screen that
matters (usually the content column), and use the rest of the frame for what the viewer needs to
read. A recording that is already portrait or square is laid out differently, as the last section
says.

| Read this | Before you |
|---|---|
| `references/landscape.md` | lay a recording out in a 16:9 frame, 1920×1080, rather than the vertical one |

Pick one layout per beat. Vary them — a promo that uses one layout for every step feels like a
slideshow; switching between two is enough.

| Layout | Use for | Frame (1080×1920) |
|---|---|---|
| **Full frame** | The hook; an outro on camera; every beat of a portrait recording | The presenter's clip, `fit: "cover"`; a portrait recording as the last section says |
| **Prompt over result** | A step that is a typed request and its answer (chat UIs, AI tools, search) | Captions at y ≈ 290, just below the band the platforms cover, a prompt bubble under them (≈ y 340–550), the recording panel below (1000×1280 at y 600–1880) |
| **Head and screen** | A step the presenter explains; the handoff out of the hook | The presenter band on top (1080×760, face in its upper half), the recording panel below (1000×1080), captions on the seam between them |
| **Screen with head bubble** | Steps where the screen needs the most room but the presenter stays present | The recording panel full height, a round presenter bubble in a corner (the ai-presenter skill) |
| **Results grid** | The end card: every result side by side | 2×2 cells (470×700, 24 px gaps), each a panel on its own result, then the call to action under the grid |

**Prompt over result is the typing beat.** Typing is the most engaging thing a chat-style recording
has, so re-type the user's prompt large instead of hoping the viewer reads the tiny input box: the
bubble is a `shape` layer (`rect` + `fill`, `roundness` ≈ 44, a fill one step lighter than the
background) faded in over 0.2 s with `opacity` keyframes (the fade presets do not apply to a shape
layer), and the prompt is a `text` layer on it whose `content.text` is a list
of lines (wrap at ≈ 30 characters for 42 px; there is no wrap box) and whose
`content.animations: [{ preset: "typewriter", params: { duration: 0.9 } }]` types it out. Start the
text 0.1 s after the bubble; in this beat the voice line starts with the text, not at
scene-building-basics's usual panel + 0.15 s. Other text entrances
(`slide_up_lines` for the end title, `fade_in_chars`) are in `picsart_scene_capabilities` →
`textAnimations`. `scripts/panels.py` builds the bubble layer, below.

**A panel is a masked media layer.** The recording is `fit: "contain"`, and the panel shape is a
mask on it: `mask: { layer: { id, transform: { position }, content: { kind: "shape", items: [ { type:
"rect", size: [w, h], roundness }, { type: "fill", color: "#ffffff" } ] } } }`. The mask's
`position` is in composition pixels and the rect is centered on it. **Every mask layer id must be
unique across the whole scene** (`s1_mask`, `grid_0_mask` …); reusing one is a
`mask_layer_id_conflict` error. A slightly larger rounded `shape` behind the panel, one step lighter
than the background, gives it a rim so it reads as a card.

**Build the pieces with `scripts/panels.py`.** From this sk

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

Referenced files: 6 — file references are metadata, not package contents.

screen-recording-zoom6.27 KB

View saved version →

---
name: screen-recording-zoom
description: The house zoom for screen footage in a panel - its scale, ramp and timing as scene keyframes, focus clamping, the readability rule, and a planner that decides which clicks of a long recording get a push. Use when timing and keyframing zooms on a screen recording shown in a panel.
metadata:
  imports: screen-recording-layouts
---

# Screen zoom

The panel already frames the content column at a readable size, so the zoom is a gentle push toward
the result, not a dive into the screen. These numbers are the house zoom:

| Parameter | Value |
|---|---|
| Rest | the content column fills the panel width |
| Peak | **1.33× over rest** — never more than 1.5× over rest; a result that is mostly white (a logo on a white card) gets 1.1× |
| Ramp | **1.0 s** in; no zoom out inside a step — the next step is a new panel |
| Zoom out | **off.** For footage that stays on one screen for minutes, where the next push is not a new panel: `zoomOut`, the ramp back to rest on the same curve, and on each focus `until`, where its hold ends and the ramp starts |
| Text floor | **off.** `textFloor`, in frame px: the peak rises until the UI's text reads at least that tall, past 1.33× if it must, and still never crops the focus box more than the push allows |
| Easing | **`cubic-bezier(0.16, 1, 0.3, 1)`** — fast start, long settle |
| Start | on a `result`: **0.1 s after the measured reveal**, so the result appears, then the frame leans in. On a `click`: 0.5 s before it, so the click lands on a settled frame (`delay: -0.5`) |
| Merge | two focus events **within 2.5 s** share one push: choose their shared peak before checking whether the pans fit in the step |

Reveals are measured, never estimated: take each reveal's settle time as the screen-recording-analysis skill
says. As keyframes on the recording layer (`t` relative to the layer, `timeMode: "layer"`), with
the trim starting 1 s before the reveal:

```
t = 0      scale = rest   position = rest framing   easing: "linear"   (waiting state, held)
t = 1.1    scale = rest   position = rest framing   easing: cubic_bezier  (reveal + 0.1)
t = 2.1    scale = peak   position = peak framing                         (terminal: no easing)
```

**Run `scripts/zoom.py` for the keyframes; never work them out.** Write the recording's size, its
panel, the content column, the layer's length and each result to lean in on (its measured reveal
in layer seconds, its box, its mean luma, and the card it sits in when there is one) to a file,
and from this skill's folder run `python3 scripts/zoom.py <file>`. It prints the layer's `scale`
and `position` keyframes with their easings, how tall the UI's text reads at rest, and any push
it had to skip because too little of the step was left. Its docstring lists every field, and
`options` sets the zoom out and the text floor. Leave both off when each step gets a new panel.
The table and the example above say what it does, for a host that cannot run it.

**Easing.** Scene keyframes take the curve exactly: `easing: { kind: "cubic_bezier", control:
[0.16, 1, 0.3, 1] }`. **A keyframe's easing shapes the segment that STARTS at it**, so put the curve
on the keyframe that begins each ramp, and mark the hold's opening keyframe `easing: "linear"`
explicitly — a keyframe with no easing draws a `linear_easing_by_omission` warning. The terminal
keyframe takes no easing (`unused_easing_on_terminal_keyframe` otherwise).

**Keep the focus inside the panel.** Clamp the framing so the zoomed window stays inside the
recording; let the focus sit off-center rather than show the panel's empty edge. The rest and peak
framings use the framing formula in the screen-recording-layouts skill; `zoom.py` clamps both and applies it. A peak
capped at or below rest keeps rest's exact scale, even when that exceeds the focus crop cap; its
scale never falls below the minimum needed to cover the panel.

**Readable beats pretty.** If UI text is unreadable in the panel, frame th

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

Referenced files: 7 — file references are metadata, not package contents.

screen-ui-redesign5.7 KB

View saved version →

---
name: screen-ui-redesign
description: Recreate the screens of a recording as designed motion UI - the app's own screens, layout, colours and words, redrawn larger and cleaner for 9:16 and built only from what the recording shows. Use when screen footage will not read at the destination, or when the UI is only the means and a designed version tells the step better.
---

# Designed UI

A screen recording cropped into a vertical frame is tiny and dense: viewers swipe at the cut to
it. The same moment, redrawn as a few large elements, reads at a glance. The redraw is a claim
about the product, so it is the app's own screen made larger, never a different one.

## What stays true

- **Redraw the real app, never invent one.** Keep its layout, the kinds of its components, its
  colours, its words and the user's own typed text. Make them larger, cleaner and fit for 9:16,
  then add motion. A light chat stays a light chat; a magenta button stays magenta.
  Never draw a different UI or a component the app does not have: dark cards labelled WIDE and
  MEDIUM, where the app shows a light shot-list board with "Shot size Medium" chips, is an
  invented UI.
- **You may crop and add the picture.** Show only the one component that matters, and add the
  shot's picture (a still) as a visual inside it.
- **Every element is something on a still.** Its words, values and states are copied from the
  still sheets, letter for letter: the same labels, the same numbers, the same order of states.
  Never add a state, an option or a result the recording does not show.
- **Fewer, not other.** Leave out what the step does not need (menus, settings rows, other
  cards). Never merge two states into one the app never showed.
- **Each state names its recording second** (`seen`). The script refuses a state without one.
  It covers the look as well as the words: every element maps to something that still shows.
- **Your own words go in labels, not in the UI**: a `tag` on a card ("kept wide") points at a
  fact the states show; a chip or a bubble holds only the app's own text.
- **A thumbnail is a still of the recording**, through the privacy pass like every still.
- Where honesty needs proof (a result the product made, a claim a viewer would doubt), one frame of
  the real recording goes beside the redraw: the hook or the payoff, held.

## Mapping the recording to elements

| On the still | Element | Fields |
|---|---|---|
| A card, a tile, a row with a picture | `card` | `title`, `chip` (its key value), `image` (a still, cropped to the picture), `tag` |
| A message typed into a chat or a search box | `bubble` | `text` |
| A setting, a badge, a value on its own | `chip` | `text` |
| A menu, a list of options | `list` | `items`, at most the ones the step uses |
| The button pressed | `button` | `label` |

The thing that changes is one element across states, never two: the card whose chip goes from
"Shot size Medium" to "Shot size Close-up" is the same card in both states, with `set` on the second.

## Building a beat

From this skill's folder, run `python3 scripts/ui_beat.py <file>`. Never place or keyframe the
elements yourself. Its docstring lists every field. In short:

- `box`, `start` and `duration`: where and when the beat plays, in frame px and scene seconds;
- `style` and `font`: the app's own colours, read from the stills (`canvas`, `surface`, `ink`,
  and its primary button's colour as `accent`), and the scene's font;
- `elements`: each element by name, with its first values;
- `states`: each screen in order, with `at` (its beat second), `seen`, `show` (top to bottom),
  `set` (what changes from here), `tap` (the element pressed to cause it) and `source` (the still
  of the `seen` second). States sit at least 1.5 s apart, so each is read before the next moves.

It prints `{layers, assets, duration, states, diagnostics}`. Add the layers to the scene and the
assets (each thumbnail is a nested scene) to its `assets`. No layer uses a mask. Act on each
`w

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

Referenced files: 1 — file references are metadata, not package contents.

sd25-pe90 KB

View saved version →

---
name: sd25-pe
description: 'Use only for a Seedance 2.5 model (model ids seedance-2.5*): optimizes text, stories, or optional multimodal references for Seedance 2.5 text-to-video, multi-reference generation, keyframes, storyboards, blockouts, video editing, audio editing, or extension. Not for any other video model, such as Kling, Veo, Wan or Seedance 2.0.'
metadata:
  owner: BytePlus ModelArk (Seedance)
  version: 0.1.1
  source: https://docs.byteplus.com/en/docs/modelark/seedance-2-5-prompt-guide
  fetched: '2026-10-28'
---

# Seedance 2.5 Prompt Optimizer

> **Vendored.** BytePlus ModelArk's official Seedance 2.5 prompt optimizer skill `sd25-pe` 0.1.1,
> installed 2026-10-28 with `npx --yes skills@latest add "https://arkdocs-en.tos-ap-southeast-1.volces.com/skills/" --skill sd25-pe --yes` and copied here
> unchanged except: the frontmatter's description is scoped to its model ids, so a host that picks
> skills by description never loads it for another model; the nested metadata is flattened to the
> strings this plugin requires, and its "Self-update before triggering" section is removed. That section told the agent
> to update the skill from npm on every first use in a session; never update this skill from a session.
> Source guide: <https://docs.byteplus.com/en/docs/modelark/seedance-2-5-prompt-guide>. Refresh it only by re-running that install outside the repo and
> copying the result here in a merge request.
>
> **In Picsart.** Aspect ratio, duration, resolution and audio are `picsart_generate` settings.
> A film's run prompt is written by `picsart_film_compile_prompt` and sent verbatim: use this
> skill to shape what goes into the compile (each shot's action, the speakers' lines and
> `language`, `extra`) and to judge the result, never to rewrite the compiled prompt, which
> `picsart_film_verify_prompt` would then refuse. A prompt written by hand (`generate-media`,
> an edit or extend) follows this skill directly.

## Purpose

Compile the user's raw text, novel excerpts, and optional image, video, and audio references into one clean Prompt that can be submitted directly to Seedance 2.5. Preserve the user's core intent, and make asset roles, subject mappings, event states, and relationships that must remain consistent explicit.

This Skill's responsibility ends after it understands the input and outputs the Prompt; under no circumstances does it call a generation API on its own. When the user explicitly requests video generation, first use this Skill to produce a clean Prompt, then submit it through a separate generation tool or workflow. This Skill always treats assets as read-only, never modifies the original assets, and never creates auxiliary assets automatically.

## When to Use

Load this Skill in the following situations:

- The user asks to optimize, rewrite, or complete a Seedance 2.5 Prompt.
- The user provides a brief idea, a long narrative, a novel excerpt, or an unstructured complex Prompt.
- The user provides images, videos, audio, file paths, or a multimodal request that requires assigning asset roles.
- The user wants multi-asset generation, a long-form video, keyframe control, a storyboard grid, blockout rendering, video editing, audio editing, or video extension.
- The user wants to improve emotional performance, camera movement, sound, dialogue language, or the depiction of a product workflow.

Do not automatically run this Skill in the following situations:

- The user only asks about API parameters, pricing, quotas, errors, or model capabilities and does not need a Prompt.
- The user only asks for an evaluation of a generated video and does not request a Prompt rewrite.

When the user explicitly asks to generate a video directly, still use this Skill first to compile the original input into a clean Prompt, then pass it to the downstream generation workflow. This Skill does not submit the task itself.

## Non-Negotiable Principles

1. **Intent First**: Do not change character identities or counts,

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

sd2-pe10.7 KB

View saved version →

---
name: sd2-pe
description: 'Use only for a Seedance 2.0 model (model ids seedance-2.0*): optimizes user prompts for Seedance 2.0 multi-modal video generation. Not for any other video model, such as Kling, Veo, Wan or Seedance 2.5.'
metadata:
  owner: BytePlus ModelArk (Seedance)
  version: 0.1.0
  source: https://docs.byteplus.com/en/docs/modelark/seedance-2-5-prompt-guide
  fetched: '2026-10-28'
---

# Seedance 2.0 Prompt Optimizer

> **Vendored.** BytePlus ModelArk's official Seedance 2.0 prompt optimizer skill `sd2-pe` 0.1.0,
> installed 2026-10-28 with `npx --yes skills@latest add "https://arkdocs-en.tos-ap-southeast-1.volces.com/skills/" --skill sd2-pe --yes` and copied here
> unchanged except: the frontmatter's description is scoped to its model ids, so a host that picks
> skills by description never loads it for another model; a metadata block naming the source is
> added.
> Source guide: <https://docs.byteplus.com/en/docs/modelark/seedance-2-5-prompt-guide>. Refresh it only by re-running that install outside the repo and
> copying the result here in a merge request.
>
> **In Picsart.** Aspect ratio, duration, resolution and audio are `picsart_generate` settings.
> A film's run prompt is written by `picsart_film_compile_prompt` and sent verbatim: use this
> skill to shape what goes into the compile (each shot's action, the speakers' lines and
> `language`, `extra`) and to judge the result, never to rewrite the compiled prompt, which
> `picsart_film_verify_prompt` would then refuse. A prompt written by hand (`generate-media`,
> an edit or extend) follows this skill directly.

## Role definition
You are a Seedance 2.0 multimodal AI director and prompt optimization expert. Your primary task is to intercept low-quality prompts piled with adjectives from users, and guide users to rewrite them into high-quality engineered prompts (three-section structure, eight core elements, multimodal reference control).

## Core workflow
When a user enters a rough prompt, provides multimodal assets (images/videos), or **only puts forward a video generation requirement (such as "Generate a video of a dog running")**, please strictly follow the steps below:

### Step 0: Requirement analysis and heuristic questioning (only when the user only provides requirements without specific prompts)
If the user only provides a rough idea or requirement (for example: "I want to make a cyberpunk-style video" or "Generate a video of a girl dancing"), you must **actively enter the guidance mode**, help the user enrich details by asking questions, and never make up content directly:
1. **Ask about core elements**: Guide the user to supplement information based on the "eight core elements".
   *Sample question*: "Regarding this video of a girl dancing, could you supplement a few details for me? For example: 1. What are the girl's appearance features and clothing? 2. Where is the dancing scene (cyberpunk street/classical stage)? 3. Do you have any reference images (@Image 1) to provide to me?"
2. **Switch to regular process after collecting information**: After the user replies with sufficient information, proceed to Step 1 and subsequent steps below.

### Step 1: Intent and scenario determination
1. Determine the generation type: is it "generating a new video" or "editing an existing video (add, delete, modify, or stitch)".
2. Determine scenario dynamics: is it "static scene (requires fine control, such as emotional details)" or "dynamic scene (retains large dynamics, cooperates with reference assets)".

### Step 2: Element self-check and asset mapping (automatic parsing)
1. **Multimodal JSON/text parsing and automatic mapping**: If the user directly pastes a complete JSON input containing a `"content"` array or a long text with a similar structure, you **must actively take the following parsing actions**:
   - Scan all objects that are not of `text` type (such as `"type": "image_url"`, `"type": "video_url"`).
   - According to their **order of appearance 

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

social-posting3.25 KB

View saved version →

---
name: social-posting
description: Post a finished video to the user's own TikTok, Instagram, YouTube or other connected accounts through the Picsart app's post preview - the connected accounts read first, a connect panel only for an account that is missing, then one preview per post whose own buttons post or schedule it. Use in edit-footage's channel-clips job, once it delivered its clips and the user says to post, publish or schedule them; never before delivery. Other jobs and use cases post as they always have, with their own steps or the social tools directly.
---

# Posting to social accounts

The app posts, not you. You read which accounts are connected, open the connect panel when one
the user wants is missing, and open a post preview with the video and a caption; the user presses
Post now or Schedule on the preview, and the result comes back to you. Nothing here spends
credits.

## When it runs

These steps are edit-footage's `channel-clips` job's. Every other job and use case keeps
posting as it always has: recast's own Post step, or the social tools called directly when the
user asks. Only after the use case delivered the video, and only when the user asks to post it or said yes
to the use case's one offer. A post is outward-facing: never open a preview the user did not ask
for, and never press its buttons for them.

## The run

1. **The accounts.** Call `picsart_social_accounts` first, every time: it is read-only and lists
   the connected accounts per platform. Say in one line where the clips can go.
2. **A missing account.** When the user names a platform with no connected account, or one that
   cannot post, call `picsart_social_connect` with those `platforms` once: the app draws a
   Connect panel. End the turn; the user connects there, and their next message says so. Then
   read the accounts again before anything else. Never ask them to describe or paste what the
   panel showed.
3. **The preview, one per post.** Call `picsart_social_post_preview` with the video's URL in
   `media`, exactly as the export returned it, the `platforms`, and a `caption`: the post copy
   the use case wrote, with a campaign's mandatory lines and handles character for character.
   Several videos are several previews, in the order the user chose them. A date or time the user
   named goes in `scheduledFor` with their `timezone`; otherwise leave both out, and the preview
   offers Post now. YouTube takes a `youtubeTitle`: the clip's title. The preview posts nothing by
   itself: it shows the post, and the user presses Post now or Schedule on it.
4. **The result.** The preview's own result says what the user did and what each platform
   answered. Say it back in one line per post: live with its link, scheduled for when, or what
   failed and on which platform. Never claim a post went live until that result says so; a
   preview that was opened and never pressed posted nothing.

Each platform's own rules (a TikTok privacy level, a YouTube title, a length cap) are read from
the preview or the tools' own replies, never assumed. A platform the tools do not list: the file is
in Drive, ready to post by hand; say so in one line.

Run it yourself. Never hand posting to another agent: the handoff loses the video URLs and what
the user said. One preview at a time, the user's pick first.
speech-aware-cutting6.1 KB

View saved version →

---
name: speech-aware-cutting
description: Choose the moments of talking footage worth keeping and cut them so no one is clipped mid-sentence - the transcript sets every in and out, the watch picks what is worth it - then read the cut as the viewer will hear it with scripts/review_cuts.py, which flags chopped words, filler and seams that open on "but" or "she", with the time to move each edge to. Use when cutting a short, a reel or highlights from an interview, podcast, vlog, talk or any footage where people speak, and when a finished cut sounds choppy.
---

# Speech cuts

A short cut from talking footage lives on its words. The framing can be perfect and the short is
still unwatchable when it opens on half a sentence or spends its first two seconds on "yeah, no,
totally". So the cut is planned from what is **said**, and checked as what is **heard**, before
anything is built.

## Read the footage

Read every source as the footage-analysis skill says for talking footage: a transcript kept as the
tool returned it (`transcript-<source id>.json` where you run commands), which sets every boundary, and a watch, which picks the moments. A photo has no speech
at all: it is a beat, not a backbone.

## Plan the cut

1. **One pool of moments.** Take the watch's candidate moments from every source into one list,
   each with the source it came from: its times count on that source's clock, as the footage-reframing
   skill says.
2. **Snap each to whole thoughts.** A clip's `in` is a sentence's first word, or a word after a
   real pause; its `out` is a sentence's last word, or a word before one. The transcript's
   `cutPoints` mark the clean ends.
3. **Order and trim to the target.** Order the moments by their loops, as the retention-hooks
   skill says. Aim for the target length within about 15%. **When the length and a clean sentence
   conflict, the sentence wins and the length moves.** Never cut a word out of a sentence to save time: the ear hears the
   splice at once, where the eye would forgive a picture cut.
4. **Place photos at sentence edges**, never inside one, each held long enough to read.
5. **Keep what the user saw work.** A recut or a fix starts from the last version the user saw,
   never from zero. Every moment they liked stays, with the picture it had; a fix for a constraint
   (a clipped word, a pause, the length) moves an edge, never swaps the moment for another. A
   moment dropped, moved or given a new picture gets one line in the message to the user. Where
   the use case keeps the edit-pipeline record, its keepers ledger and `scripts/meaning_diff.py`
   do this, as the edit-pipeline skill says.

Write the plan as the reel's clip list, the one the footage-reframing skill's `scripts/reel_cut.py` reads,
with each spoken source's `transcript` beside its other fields (its file path, where you run commands).

## Review it as heard

Run `python3 scripts/review_cuts.py reel.json` on that same file. It joins each clip's words in
play order into the **heard script**, and checks three things per clip:

| Check | Fails when | Its repair |
|---|---|---|
| Integrity | an edge cuts through a word, or the clip opens or stops mid-sentence | move that edge to the time given |
| Substance | most of the clip is filler; the opening clip is held to a stricter share | drop it, or take the sentence beside it |
| Fluency | a clip opens on a connective ("but", "so") with nothing before it, or the reel opens on a pronoun no one has been named for | move the in point back to what it refers to, or lead with another clip |
| Context | a clip opens on an answer ("Yes", "Exactly") whose question the cut drops | move the in point back to the question |

Each clip also lists the `speakers` its words carry. Use them when the footage-reframing skill asks who a
clip should hold on.

The review also returns `context`: each name the reel says for the first time, each "she" or "that"
right after a seam, each "as I said", and each seam that jumps far in 

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

Referenced files: 1 — file references are metadata, not package contents.

spoken-captions6.58 KB

View saved version →

---
name: spoken-captions
description: Put spoken words on screen from the transcript - word-timed captions on a generated voice-over or on the user's own talking footage, and on a cut reel, captions per clip and a few highlight phrases timed to the words they call out, placed with scripts/reel_text.py. Use when a video is watched muted and its speech must be read, or when a short's key lines should land on screen.
---

# Captions

Every word on screen comes from a transcript, with its times as the transcript gives them. **Never
rewrite the word times.** A caption carries only what is said: never a speaker's name the viewer has
not heard, a stage direction or a row label.

## The transcript

1. **Probe before you transcribe.** Check `hasAudio` from `picsart_media_probe` first, and
   skip only when it reports `hasAudio: false`, as the footage-analysis skill says.
2. Transcribe with `picsart_media_transcribe`:
   - a voice-over you generated: **each generated voice line**. It is our own clean audio, so the
     word edges are exact.
   - the user's own footage: each source once, as the footage-analysis skill says. Reuse that
     transcript; never transcribe a cut.

The tool's `notes` name any segment it returned without word times. Caption that segment as one
block over its own start and end; it cannot carry a highlight.

## Captions on a voice-over

Place each line as a `captions` layer through `picsart_scene_patch`:
`content: { kind: "captions", transcript, timeOffset }`, where `transcript` is the tool's
`transcript` as returned (it is already shaped for a captions layer) and `timeOffset` is the
line's start in the video.

2–4 words per caption. The caption style's `offset` is measured from the frame center
(`[0, -670]` puts it at y ≈ 290 in a 1080×1920 frame, below the top 250 px the platforms cover); keep captions in a dark band of the
layout, never over a panel or the focus point.

**Readable over any picture, and the spoken word lit.** A caption crosses moving footage, so give
its style an outline and light the word being spoken:

```json
"style": {
  "effects": [{"id": "stroke", "params": {"width": "<px>", "color": "<outline colour>"}}],
  "decorations": [{"target": "highlighted", "place": "text", "color": "<highlight colour>"}]
}
```

Read the effect's id and params from `picsart_scene_capabilities` (`effects`) rather than
from here; this shape passed `picsart_scene_validate` on 2026-10-05. One highlight colour
for the whole video, the brand's when it has one.

## Words on a cut reel

A reel cut from the user's footage plays each source in pieces, so its words are placed from the
scene the user approved, with `python3 scripts/reel_text.py words.json`:

```json
{
  "scene": "scene.json",
  "transcripts": {"talk": "transcript-talk.json"},
  "captions": {"style": {"font": {"size": 64}, "offset": [0, 440]}},
  "highlights": [
    {"clip": 0, "say": "revenue tripled", "text": "Revenue tripled"},
    {"clip": 4, "say": "nobody tells you this"}
  ]
}
```

`transcripts` maps each spoken source's asset id to its transcript (its file, where you run
commands). The script builds the words into the scene: where you cannot run commands, stop as
picsart-video-rules says for a script that builds the scene. Ask for `captions`,
`highlights` or both. The script reads each clip's place on the reel and its trim from the scene,
so a clip the user retrimmed in the editor is read as they left it, and it prints the scene with
the new layers on top. A phrase it had to cut short comes back in `notes`.

- **Captions** become one `captions` layer per spoken clip, open while that clip plays its
  source, with the source's transcript as returned. A clip held past its `trim.out` freezes on its
  last frame, so its captions close where the trim ends. The reel ends at the composition's
  `duration`, or with none at the track layer's: captions stop there. A photo, a `muted` clip, a
  shot without a transcript or a clip past the reel's end gets none, and

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

Referenced files: 1 — file references are metadata, not package contents.

visual-style5.17 KB

View saved version →

---
name: visual-style
description: A video's style, chosen by eye and kept - eight named styles as colour roles and text entrances, a brand's colours mapped onto one, the defaults that make a video look machine-made, and a check that a built scene keeps to its style. Use when choosing or applying the look of a built video (screen videos, promos, tutorials), or checking that one does not look generic.
---

# Art direction

A video looks made by hand when its colours, type and motion were chosen for it, and generic when
they were left at a default. This skill holds the choice: a **style** is a palette by role and a
text entrance per role, which a builder takes instead of colours of its own.

## The styles

`scripts/style.py` holds them; run it with no arguments for each one's tokens. To the user they
are "styles", never tokens.

| Style | Feel | Suits |
|---|---|---|
| `studio-dark` | premium, cinematic: deep plum, warm off-white words, coral payoff | a launch, a dark UI, creative tools |
| `paper-ink` | calm, editorial: warm paper, near-black ink, a red pencil mark | how-tos for beginners, writing and planning apps |
| `pop-block` | loud, social: flat sunflower, black words, hot pink | Reels and TikTok for a young audience |
| `keynote` | clean product: light grey stage, one electric blue | a feature explainer, a B2B tool |
| `sticky-note` | friendly how-to: notepad yellow, an orange marker, typed titles | tips, "save this for later" shorts |
| `terminal` | technical: green-tinted black, mint text, typed lines | developer tools, AI chats |
| `bloom` | warm, creative: berry stage, blush words, peach payoff | photo, video and design apps |
| `native` | creator-made, not an ad: minimal chrome around the recording | content that should not read as an ad |

Roles: `canvas` is the frame behind everything, `surface` the cards, bubbles and rims, `ink` every
word (it reads on both), `accent` the payoff and the call to action, and `entrance` the text
entrance for titles, lines and the call to action.

## Choosing one

1. **Recommend from the material**, never by habit: the recording's own brightness and colours,
   the product's category, the destination and the audience. Say the reason in one line: "a bright
   UI and beginners: paper-ink keeps it friendly and lets the app's colours lead".
2. **Show three that differ**, on the user's own recording, before anything is rendered: the same
   hook frame and one step frame built in each, side by side in `picsart_scene_picker` (free), each
   card labelled by how it looks to them ("paper and ink, friendly"), not by its id. Never ask for a
   style by its name alone and never pick it for them; go on from the one they keep and say which
   (picsart-video-rules, "A choice made by eye").
3. **A brand** (colours the recording shows, or the user gives) goes onto the chosen style's roles:
   `python3 scripts/style.py <style> brand.json`. The style keeps its bones; the brand gives its
   colours. A brand colour that would make the words unreadable is refused with the role it
   breaks: keep that role from the style.
4. Pass the style's id, and the brand when there is one, in the builder's spec as `style` and
   `brand`. The builder resolves them; never copy colours into the spec by hand.

## Defaults that look machine-made

Check a build against this list before the user sees it. Each hit is fixed, or kept with a one-line
reason ("the app itself is navy, so the canvas follows it"):

- the same dark navy or black stage whatever the subject;
- every text entering the same way;
- everything centred, with nothing breaking the grid;
- a push-in as the only move;
- pure `#000000` or `#ffffff` as the canvas or the words;
- purple-to-blue gradients, gradient text, and full-frame gradients on a dark canvas (they band
  when the video is compressed);
- a hook that opens on a login screen or an empty app instead of the result;
- a hook that is a product or a posed character with a slogan over it: the retention

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

Referenced files: 2 — file references are metadata, not package contents.

voice-over-generation1.59 KB

View saved version →

---
name: voice-over-generation
description: Generate a voice-over from written lines - one voice line per script line in one voice, as one batch, the words alone with pace and energy in the model's own fields, names spelled as they sound, and every line's real length probed before anything is timed to it. Use when a video needs a generated voice, with a presenter on screen or with no face at all.
---

# Voice-over

A voice line is a generated clip of one line of the script. The lines are written by whoever needs
them (a presenter's script, a step's narration); this is how they become audio that the picture
can be timed to.

- **Voice.** One voice line per script line, in the same voice, generated with `picsart_generate`
  as one batch (picsart-video-rules, SPEND). Pick the voice model with `picsart_model_catalog`, and read
  its voices and inputs with `picsart_model_params`.
- **The line is only the words.** Energy and pace go in the model's own fields, as
  `picsart_model_params` names them, never typed into the text. Spell an unusual name the way it
  sounds in the line you send, and keep its written spelling for the captions and the text on
  screen. Pass a language as its two-letter code (`en`), never a region code, unless the model's
  fields list that exact value.
- **Length.** Speech runs at about three words a second, so a 4 s step holds about twelve words.
  Probe every voice line's real length with `picsart_media_probe` before anything is timed to
  it. When a line is longer than the time it has, shorten the line; never stretch the picture to
  fit it. Only that line is generated again.

Release notes

Picsart - v2.5.0 Generate media, edit scenes, direct short films and motion design, and share results to connected social accounts from conversation. What changed in this version: - Brand Kit: read the connected account's brand kits and their details for use in creative work. - Scenes: save and browse versions in a private scene library, filter them by kind, and reuse them in scenes. A selection board lets the user choose between scene options. - Comics: a setup board lets the user choose a creation and photos. Video Comic and Video Tale replace the animated video option, and the motion episode option has been removed. - Films and Recast: the Cast Chooser opens on ready-made characters, editor notes and Recast progress work in ChatGPT, and the workspace offers a Recast card. - Media and exports: HEIC photos can be used as inputs, audio exports play in their own row, and the rendering and export cards work better on phones. - The Drive browser shows scene library items as portrait cards with a Scenes filter, and keeps loaded-file filters usable when a widget call is unavailable. Browse model options and parameter schemas, validate a request and inspect its credit estimate before generation; paid work starts only after the user approves it. Long jobs report progress, and completed results offer Open and Download links. Background removal, replacement, enhancement and vectorization create new media while preserving originals. Film Setup, the Cast Chooser, the Shotlist Board, Asset Review and the Recast board collect the user's choices before prompts are compiled for generation, and the Scene Editor lets the user review and edit scenes before export. Decisions require actual widget feedback before the assistant continues. Generated and edited media is saved to Picsart Drive where supported, and a save is reported only when confirmed.

Declared in the saved package. Remote tools may change independently.

Package details

Publisher declarations from the archived package. These are separate from our research and the live service's terms.

Package author
Picsart
Keywords
See keywords
Getting started skill
./skills/get-started/SKILL.md
Commerce declaration
Does not support commerceThis does not establish whether access is free or paid.
Review scenarios
5 positive · 3 negativeScenario counts, not test results.

Declared capabilities

  • Interactive
  • Read
  • Write

Package observed Nov 16, 2026.

Technical details
First seen
Sep 30, 2026 · 22:02 UTC
Last seen
Nov 16, 2026 · 00:00 UTC
Latest observed change
Nov 11, 2026 · 00:08 UTC
Collection status
Collected

plugin_asdk_app_6a18d4c190a0819186e6b129a09e931e

Download plugin data (JSON)

Plugin details: freshly prepared. Prepared . Refreshed when plugin data changes or after 6 hours. Your account and Follow status are live.