Claude + Higgsfield movie tutorial

The exact workflow from my video. Connect Higgsfield to Claude once, then turn any image into a cinematic clip using two copy-paste skills. No editor, no render farm, no per-video fees.

Claude can't make video on its own. Higgsfield gives it the power.

Claude is the brain. It writes the prompts, runs the workflow, and makes the creative calls. But out of the box it can't render an image or a video. So we bolt on a Higgsfield connector (an MCP plugin), and suddenly Claude can generate images and full videos on command, right inside your chat.

The reason this ends up unlimited and free is the offer below: sign up to Higgsfield through my link and you get the Free Unlimited Vol. 2 access, then connect that account to Claude once. After that, the two skills on this page do the heavy lifting.

Here's the 3-step method from the video:

Step 1 — Install the plugin. Add the Higgsfield connector in Claude. This is what gives Claude the ability to generate images and videos.

Step 2 — Keyframes. Grab a few images you like, paste them into Claude, and run the first skill. It breaks the images down and hands you clean start frames to build from.

Step 3 — Animate. Paste a start frame back into Claude and run the second skill. AI video works by generating a ton of frames back-to-back from that one start frame, and this skill drives the whole thing into a finished clip.

Get Free Unlimited Higgsfield

This is the one thing that makes the whole workflow possible. Sign up through the link to unlock the Free Unlimited Vol. 2 access, then connect it to Claude in Step 2. Without this, the skills have nothing to render on.

/image-analysis — The Keyframe & Start-Frame Generator

This is the "first prompt" from the video. Paste your reference images into Claude, run this skill, and it reverse-engineers each one into a precise, reusable prompt you can regenerate through Higgsfield to get your start frames. Make sure your Higgsfield connector is live so Claude can actually generate the frames it describes.

---
name: image-analysis
description: Deep, replication-grade breakdown of any reference image so it can be regenerated or varied. Use when the user shares an image to analyze, decode, reverse-engineer, recreate, "make similar," or to build start frames / keyframes for an AI video. Produces a readable breakdown plus a generic prompt and a granular field-by-field JSON prompt.
---

# Image Analysis

## What this skill is for
The user is an AI image and video creator. When they share an image, they want it taken apart completely, not summarized. The driving question behind every analysis is:
"If I had to regenerate this exact image from scratch, what would I need to specify?"
Analyzing to that standard is the job even when replication is not the stated goal. Most follow-up requests will be variations: "make similar," or "keep everything the same but change the color tone," or "same lighting and framing but a different subject." That only works if the first analysis was granular enough that any single attribute can be swapped while everything else stays fixed. So: over-analyze on purpose. Depth here is a feature, not verbosity.

## Mindset before writing anything
Look at the image properly first. Do not pattern-match from a glance. Move your attention through it in passes:

* The subject: face, gaze, expression, pose, hands, wardrobe, hair, skin.
* The edges and corners: what is cropped, what is in negative space.
* The light: where it comes from, how hard or soft, where the shadows fall, the color of the light.
* The darks and the brights: are blacks crushed or lifted, are highlights blown or rolled off.
* The surfaces: skin texture, fabric weave, material finish, grain.
* The overall finish: is this a photograph, a render, a collage, a paper-cut, a stop-motion frame, an illustration.

For every observation, also reason about the why and the technique. "Muted colors" is not an analysis. "Desaturated editorial grade with lifted blacks and a cool white balance, which reads as premium and restrained" is, because that is the thing you would actually reproduce.
If the user refers to an image but none is actually attached, ask them to share it rather than guessing.

## Workflow

1. Confirm what is in front of you (one image or several).
2. Work through the full checklist below for each image. Consult `references/analysis-dimensions.md` when you need precise vocabulary for lighting patterns, color grades, lens character, mediums, or film stocks. Using the right term matters because it is what makes the prompt reproducible.
3. Produce the output in the exact structure described under "Output format."
4. For multiple images, analyze each one fully, then add a shared-style summary.
5. Stop and let the user direct the next step (replicate, make similar, change one attribute, etc.). When they do, reuse the JSON as the base and change only the fields they name.

## The analysis checklist
Cover all of these for each image. If something genuinely does not apply, say so briefly rather than skipping silently.

* Medium and genre: photograph, 3D render, illustration, paper-cut, stop-motion, mixed media, etc., and the genre within that (high-fashion editorial, documentary portrait, product, beauty, lifestyle, conceptual).
* Format: aspect ratio and orientation.
* Subject(s): who or what, and if there are several, each one separately. For each: appearance, skin tone (call it out explicitly, generators drift on this), expression, gaze, pose and body language, wardrobe, hair and makeup, distinguishing details. When there are several, also note how they relate and are arranged.
* Secondary elements: props and supporting objects.
* Setting: location, background, set design, depth layers (foreground, midground, background).
* Composition: shot type, framing, subject placement, negative space, symmetry and balance, leading lines.
* Camera: angle, height, distance, focal-length character, perspective.
* Lens and optics: depth of field, focus point, bokeh, distortion, flare or aberration, motion blur if anything is moving.
* Lighting: full setup (key, fill, rim or back), direction, hard or soft quality, contrast ratio, color temperature, source and time of day, how shadows and highlights behave, and the catchlight shape in the eyes when a subject is present.
* Color: palette with hex values, dominant and accent colors, saturation level, the grade, white balance, tonal range and contrast, and the intent behind the choices.
* Texture and material: skin texture, fabric, surface finishes, tactility.
* Post-processing: grain or noise, film emulation, retouching level, vignette or halation or bloom, sharpening, deliberate artifacts.
* Typography and text: present or not, content, font style, placement, treatment. (Important for carousels.)
* Mood and emotion: the feeling it communicates.
* References and era: art movement, decade, or brand vibe it evokes.
* Technical quality: resolution feel and rendering fidelity.

## Output format
Use this exact structure. Keep the prose clean and editorial. Do not use em dashes anywhere in the output; use periods or line breaks instead.

```
## [Short title describing the image]

### Breakdown
A walk through the checklist, grouped under clear subheadings (Medium and genre, Composition, Subject and styling, Color and grade, Lighting, Camera and lens, Texture, Post-processing, Typography, Mood). Every element carries its why or technique, not just a label.

### Generic prompt
One paragraph of natural language that captures the full image and could be pasted into any generator. Fully self-contained: it names the subject, setting, lighting, camera, color, and finish in plain words, with no reference to "the image above" or "as described."

### JSON prompt
The structured, field-by-field prompt (schema below) as valid JSON.
```

## The JSON prompt
This is the centerpiece. It must be valid JSON (no comments, no trailing commas) and every field filled with specific, concrete values rather than vague ones. Granularity is the point: each field is independently editable, so a later "change only the color tone" request means rewriting one block and leaving the rest untouched.
Always keep it self-contained. Never write "same as previous" or reference an earlier prompt, because each generation has zero memory of any other. Every JSON prompt must stand fully on its own.
The `style_signature` field is a single compact line summarizing the overall look (for example "moody desaturated editorial, single hard key, 85mm compression, lifted matte blacks"). It exists so the user can lift just that line and reuse it as a style anchor on other prompts when they want a similar feel without carrying the whole object.
Use this schema:

```json
{
  "medium": "",
  "genre_style": "",
  "aspect_ratio": "",
  "style_signature": "",
  "subjects": [
    {
      "main": "",
      "appearance": "",
      "skin_tone": "",
      "expression_gaze": "",
      "pose_body_language": "",
      "wardrobe": "",
      "hair_makeup": "",
      "notable_details": ""
    }
  ],
  "subject_interaction": "",
  "secondary_elements": "",
  "setting": {
    "location": "",
    "background": "",
    "depth_layers": "",
    "set_design": ""
  },
  "composition": {
    "shot_type": "",
    "framing": "",
    "subject_placement": "",
    "negative_space": "",
    "symmetry_balance": "",
    "leading_lines": ""
  },
  "camera": {
    "angle": "",
    "height": "",
    "distance": "",
    "focal_length_equiv": "",
    "perspective": ""
  },
  "lens_optics": {
    "depth_of_field": "",
    "focus_point": "",
    "bokeh": "",
    "distortion": "",
    "flare_aberration": "",
    "motion_blur": ""
  },
  "lighting": {
    "setup": "",
    "key": "",
    "fill": "",
    "rim_back": "",
    "direction": "",
    "quality": "",
    "contrast_ratio": "",
    "color_temperature": "",
    "source_time_of_day": "",
    "shadows": "",
    "highlights": "",
    "catchlight": ""
  },
  "color": {
    "palette_hex": [],
    "dominant": "",
    "accent": "",
    "saturation": "",
    "grade": "",
    "white_balance": "",
    "tonal_range_contrast": "",
    "intent": ""
  },
  "texture_material": "",
  "post_processing": {
    "grain_noise": "",
    "film_emulation": "",
    "retouching_level": "",
    "vignette_halation_bloom": "",
    "sharpening_clarity": "",
    "deliberate_artifacts": ""
  },
  "typography_text": {
    "present": "",
    "content": "",
    "font_style": "",
    "placement": "",
    "treatment": ""
  },
  "mood_emotion": "",
  "references_era": "",
  "technical_quality": "",
  "negative_prompt": ""
}
```

## Multiple images
Analyze each image fully and separately, in its own block with its own breakdown and prompts. Then add one final section:

```
## Shared style summary
```

This captures the visual system the set has in common: the palette and grade, the lighting logic, the framing and crop conventions, the typographic treatment, the post-processing fingerprint, and the overall mood. The purpose is to let the user generate new images that sit naturally inside the same set or carousel. Be specific enough that the summary itself could seed a fresh on-brand image.

## Handling follow-up requests
After the analysis, the user will usually want to act on it. Common patterns:

* "Replicate it" or "recreate this": deliver the JSON prompt as is, ready to paste.
* "Make similar": keep the structural fields (medium, lighting, camera, grade, composition) and vary the surface ones (subject, wardrobe, props, setting) so the new image shares the look without being a copy.
* "Keep everything, change only X": rewrite only the field or block for X. Re-emit the entire JSON so it stays self-contained, with every other value identical to before.

In all cases the emitted prompt must remain complete and standalone. Do not hand back a fragment or a diff.

No connector yet? This skill needs Higgsfield connected to render your frames.

/motion-design — The Animator

This is the "second prompt" from the video. Paste a start frame into Claude and run this skill. It walks you through a brief, builds a storyboard, then drives your Higgsfield connection to animate the frame into a finished video, exactly like the clip at the end of the reel.

---
name: motion-design
description: Drives a full motion-design creation flow (brief, storyboard, video, iterate) across any connected image + video platform such as Higgsfield. Use to animate a logo or image, make a video from a still, create an animated ad or promo, or turn a start frame into a finished clip.
---

# Motion Design Skill
You are guiding the user through a full motion design creation flow. The creative process is the same no matter which generation platform you run on. Your job is to drive the workflow (brief, storyboard, video, iterate) and map each step onto whatever image and video generation tools the user has connected. Follow each step in order. Be concise and direct. Speak in the same language the user is using.
This skill is platform-agnostic on purpose. Higgsfield, Runway, Magnific, Arcads, Ideogram, ImagineArt, and similar connectors all expose the same core building blocks: generate an image, upload an asset, animate an image into video, and show the result. Pick the platform first, then use that platform's own tools for every step.

## What this skill needs from a platform
The flow needs five capabilities. Every supported platform has them, just under different tool names:

1. Generate an image from text, ideally with reference-image support.
2. Upload or register a user-provided asset (logo, product photo).
3. Generate a video from an image (image-to-video), or from text.
4. Display or retrieve the finished result.
5. Optional: list available models, and check remaining credits.

Never hardcode tool names or model IDs from memory. Use `tool_search` to load the chosen connector's tools, then read the tool descriptions to find the right one for each capability. Tool names and model IDs change often, so always confirm against what is actually loaded rather than assuming. A compact reference of strong defaults per platform is at the bottom of this skill.

## STEP 0: Pick the generation platform
Decide which platform to run on before any creative work:

* If the user named a platform (for example "make this in Runway", "use Higgsfield", "do it on Arcads"), use that one.
* If only one suitable image-plus-video connector is available, use it silently.
* If several are connected and the user did not specify, ask once:

"Which platform should I use for this? You've got [list the connected options]."
Once chosen, load that platform's tools with `tool_search` so you know its exact image, upload, and video tool names before continuing. If a platform can only do images and not video (for example Ideogram), use it for the base image or storyboard, then animate on a platform that does image-to-video.

## STEP 1: Determine the flow type
Identify which workflow applies:
classicMD: standard ads, brand promos, service presentations, logo reveals, general atmospheric content. highMD: sports promos, tech product launches, music teasers, AI capability demos, fashion drops. Prioritizes extreme camera speed, aggressive cuts, peak dynamics. Realistic people are replaced by silhouettes, chrome elements, or 3D abstract figures.
If the user's request makes the flow obvious, proceed silently. If ambiguous, ask:
"Which style fits your project better?"
Options:

* Classic Motion: smooth transitions, elegant typography, cinematic feel.
* Hyper / Kinetic: fast cuts, extreme dynamics, aggressive transitions, CGI energy.

## STEP 2: Brief intake (single message, all at once)
Ask all intake questions in one message using `ask_user_input_v0`. Do not split into multiple questions.
Questions to ask simultaneously:

1. Do you have existing assets?
   * Yes, I'll upload a logo / product photo / reference
   * No, help me create the visual
2. Video duration:
   * 5 sec: teaser / logo sting
   * 10 sec: standard post / stories
   * 15 sec: promo / product video
3. Frame format:
   * 16:9: horizontal (YouTube, website)
   * 9:16: vertical (Reels, TikTok, Stories)
   * 1:1: square (Feed)
4. Mood / style: (free input) Example prompts: energetic, minimalist, luxury, technological, atmospheric, aggressive, cinematic
5. Brand name / product name and tagline (if any)
6. Number of storyboard frames:
   * 6 frames: standard
   * 8 frames: detailed
   * 9 frames: maximum coverage

Save all answers before proceeding.

## STEP 3: Asset handling
If user HAS assets:
Ask them to upload the file directly in chat. Accept PNG, JPG, SVG, or any image.
Once uploaded, note the file path from the uploads folder, then register it with the chosen platform's media-upload tool. Platforms differ here: some need an upload step followed by a confirm step, some accept a direct URL import, and some (like Arcads) ingest a local path automatically. Read the tool description to see which pattern applies. Then proceed to STEP 4.
If user has NO assets:
Generate a base visual with the platform's strongest text-to-image model that follows instructions well and supports reference images. Construct a prompt from their brief: brand name, mood, style, color palette, aspect ratio.
Pick the model by capability, not by a fixed name. Confirm available image models with the platform's model-listing tool if unsure, and prefer the highest-quality variant the account can run. See the platform reference at the bottom for good starting points.
Generate the image, display it, then ask: "Does this image work or would you like changes?" If changes are needed, regenerate with an adjusted prompt. Once approved, proceed.

## STEP 4: Generate the Storyboard
This is the core creative step. Generate a storyboard with N frames (where N = the count chosen in Step 2: 6, 8, or 9).
Each frame must:

* Be visually consistent with the approved asset / generated image
* Represent a distinct moment in time (opening, build, climax, resolution, logo lock)
* Show camera position, subject state, motion blur / freeze where relevant
* Include a 2 to 4 word text caption burned into the frame (scene label, not subtitle)

For classicMD frames: smooth compositions, elegant typography zones, cinematic lighting. For highMD frames: peak-action freeze frames such as frozen splashes, shattered elements, material stretch, aggressive camera angles, neon contrast.
Generation approach:
Call the platform's text-to-image tool once to generate a single storyboard sheet: one image containing all N panels arranged in a grid. Do NOT generate N separate images. Use a strong instruction-following image model so the panel labels and layout come out clean.
Pass the approved asset / generated visual as a reference image in the call if the platform's image tool supports references.
Construct the prompt as:

```
Storyboard sheet with [N] sequential panels in a grid layout, each panel labeled "Frame 1", "Frame 2", etc. Panel 1: [scene description]. Panel 2: [scene description]. ... Panel N: [logo lock / brand name]. Each panel shows: [camera angle], [motion state], [mood/lighting]. Visual style: [cinematic/kinetic]. Consistent color palette throughout. Clean storyboard design, thin border between panels, [aspect ratio per panel].
```

After the single image is generated, display it.
Then present the storyboard summary:
Storyboard: [Brand Name] Frame 1: [brief scene description] Frame 2: [brief scene description] ... (all frames) Frame N: [logo lock / CTA]
Mood: [mood] Motion: [motion description, for example spiral flythrough, match-cut, slow push] Ending: [how the video ends]
Ask:
"How does the storyboard look? Approve or any changes?"
Options:

* Approve : proceed to STEP 5
* Changes needed : ask what to change, regenerate the storyboard sheet with corrections, repeat approval

## STEP 5: Generate the Video
Once the storyboard is approved, generate the final video with the platform's strongest image-to-video model. Confirm the exact model ID with the platform's model-listing tool if needed, and prefer the best-quality option the account supports.
Construct the video generation prompt combining:

* Approved storyboard narrative (scene sequence)
* Flow type (classicMD / highMD)
* Duration from Step 2
* Aspect ratio from Step 2
* Mood and style from Step 2
* Brand name / slogan for logo lock at the end

classicMD prompt template:

```
[Style]: smooth motion design, [scene flow from storyboard], elegant transitions, [mood] atmosphere, cinematic camera movement, [duration]s, brand reveal at end: [brand name], [aspect ratio]
```

highMD prompt template:

```
[Style]: high-intensity kinetic motion, [scene flow from storyboard], extreme camera speed, aggressive match-cuts, peak-action freeze frames, [mood] CGI aesthetic, neon contrast, [duration]s, hard stop logo lock: [brand name], [aspect ratio]
```

For highMD: the final seconds must be a static hold on the brand name / logo. Build this into the prompt explicitly. Scale proportionally: about 1 sec for 5s clips, about 2 sec for 10s clips, about 2 to 3 sec for 15s clips.
Start frame: pass the original uploaded asset (if the user had one), otherwise the first approved storyboard frame, as the video's starting image. Platforms expose this through different parameter names such as `start_image`, `startFrame`, `firstSceneImage`, `image_url`, or `referenceImages`. Read the tool description and use whichever one applies.
Generate the video, then display the result.

## STEP 6: Review & Iterate
When the video renders, present it and ask:
"Done! What do you think?"
Options:

* Love it, downloading : done
* Want a different edit : regenerate with an adjusted prompt, keep the same storyboard
* Want a different style : go back to Step 1 with a new style/mood
* Make another version : generate a second version with a slight prompt variation. If the platform supports a batch/count parameter, use it to render variations in one call

## Notes & Rules

* Platform-agnostic first: the workflow never changes, only the tools do. Pick the platform in Step 0, load its tools with `tool_search`, and map each step onto that platform's image, upload, video, and display tools.
* Never hardcode tool names or model IDs. Confirm them with `tool_search` and the platform's model-listing tool every time, because they change.
* Image step: use the platform's strongest instruction-following text-to-image model with reference-image support. Prefer the highest-quality variant the account can run.
* Video step: use the platform's strongest image-to-video model. Prefer the best-quality option available.
* Storyboard = one image: a single grid sheet with all N panels, generated in one image call. Never generate N separate images.
* No moodboard step: go directly from brief to storyboard.
* highMD rule: no realistic humans, only silhouettes, chrome figures, or 3D abstract shapes.
* highMD rule: logo lock duration is proportional to clip length (about 1s / 2s / 2 to 3s for 5s / 10s / 15s clips), built into the prompt.
* classicMD logo: can appear as opener, closer, or both. Ask if not specified.
* Language: always match the user's language.
* Credits: if the user seems concerned about usage, check the balance with the platform's credit tool before generating.
* On failure: explain briefly and offer a retry with adjusted parameters, or offer to switch to another connected platform.

## Platform reference (starting points, confirm with `tool_search`)
These are good default model choices per platform. They are starting points, not hard rules. Always confirm the current model IDs and the exact tool names with `tool_search` and the platform's model-listing tool, since they change often.

Higgsfield

* Image: `generate_image` with Nano Banana Pro or GPT Image 2.
* Video: `generate_video` with Seedance 2.0 or Kling 3.0.
* Upload: `media_upload` then `media_confirm`, or `media_import_url` for a web URL.
* Display: `job_display`. Models: `models_explore`. Credits: `balance`.

Runway

* Image: `generate_image` (nano-banana-pro, gpt-image-2, or gen-4).
* Video: `generate_video` (seedance-2, kling-o3-pro, veo-3.1), or `generate_multishot_video` for a 3 to 5 scene sequence.
* Upload: `init_upload` then `complete_upload`. Status: `get_task`.

Arcads

* Image: `arcads_generate_image` (nano-banana-2, gpt-image-2, seedream).
* Video: `arcads_generate_video` (Kling 3.0), or model-specific tools like Seedance 2.0, Veo 3.1, Sora 2.
* Upload: local paths are uploaded automatically. Result: `arcads_get_asset`.

Magnific

* Image: `images_generate`.
* Video: call `video_plan` first, then `video_generate`. Poll with `creations_wait`.
* Upload: `creations_upload_image` (URL) or `creations_request_upload` then finalize.

Ideogram (image only, strong text rendering)

* Image: `generate_image` (Ideogram 4.0). Good for the base image or storyboard sheet.
* No native video. Animate the result on a platform that does image-to-video.

ImagineArt

* Image: `generate_image`. Video: `generate_video`.
* Status: `fetch_image_status` / `fetch_video_status`.

Easiest — Paste straight into a chat or Project (works on mobile)

Follow these instructions as a skill.

Slash commands — Save them as real Skills

~/.claude/skills/<name>/SKILL.md

~/.claude/skills/motion-design/SKILL.md

• "Here are 3 images I like — /image-analysis" — get clean start frames

• "Recreate this frame but change the color tone to warm gold"

• "/motion-design — animate this start frame into a 5s vertical clip"

• "Make it hyper / kinetic with a hard logo lock at the end"

• "Make another version, more cinematic"

• "Reframe it to 9:16 for Reels"

This is one workflow. If you want the rest of the system — the automations I actually run my content and my business on — that's what I share on @the.agi.guide.

Ready to make your first unlimited video?

Connect Higgsfield free, paste the two skills into Claude, and you are one prompt away from a finished clip. Grab the access, then come back and run it.