Turn Any Script Into an Instagram Carousel With One Claude Skill

What you're getting

You already write scripts. Video scripts, hook lists, post copy sitting in a doc. Most of them never become posts because turning words into slides means opening a design tool, fighting with layouts, and exporting at the right size.

This guide hands you a single Claude skill that removes that step. Install it once. Paste in a script you already wrote. Add your brand color if you want it. Claude splits your script into slides, renders each one at the exact Instagram size (1080×1350), and gives you finished PNGs to download and post.

Below is the complete skill file, exact install steps for every place Claude runs, the input format, branding options, how to download and upload your slides, a full worked example, and troubleshooting. Everything you need to do this today.

At Hypd we run this exact pattern internally — one script in, a carousel out — and the skill below is the portable version you can drop into your own Claude.

The skill file (copy this exactly)

A Claude skill is just a folder with one file named SKILL.md. The file starts with YAML frontmatter (name and description are required) and then tells Claude what to do.

Copy everything between the lines below into a file named SKILL.md. This is the whole skill — no other files required.

markdownCopy
---
name: script-to-carousel
description: Turn a written script into finished, upload-ready 1080x1350 Instagram carousel slides saved as downloadable PNGs. Use when the user pastes a script, talking points, or post copy and wants carousel slides built for them.
---

# Script to Carousel

Turn a written script into a finished Instagram carousel: a set of 1080×1350 PNG
slides the user can download and post as a single carousel.

## When to use
Fire this skill whenever the user pastes a script, a list of points, or post copy
and asks to "turn this into a carousel," "make carousel slides," or similar.

## Inputs you accept
- **script** (required): the written copy. Any length. A video script, numbered
  steps, or paragraphs all work.
- **brand_color** (optional): a hex value like `#6C47FF`. Used as the accent.
  Default `#6C47FF`.
- **background** (optional): `dark` or `light`. Default `dark`.
- **style_notes** (optional): tone or font hints, e.g. "bold sans, high contrast."

If branding is missing, use the defaults and continue. Never block on branding.

## Step 1 — Split the script into slides
Break the script into 6–9 slides:
1. **Slide 1 (cover):** the single strongest line, rewritten as a scroll-stopping
   hook. Headline ≤ 9 words, subline ≤ 14 words.
2. **Body slides (2 … n-1):** one idea per slide. Headline ≤ 9 words, supporting
   line ≤ 22 words. Keep the script's order. If the script has numbered steps,
   put one step per slide.
3. **Final slide (CTA):** the call to action. Use the script's keyword/offer if it
   names one; otherwise default to "Follow for more."

Rules:
- One idea per slide. Never crowd a slide.
- Rewrite for punch — do not paste raw paragraphs.
- Never invent facts that are not in the script.
- First print a short plan (slide number → headline → subline) and show it before
  rendering.

## Step 2 — Render the slides
Run the Python below in code execution. Fill in SLIDES, BRAND, and MODE from the
plan and the user's branding. It writes slide_01.png … slide_NN.png at 1080×1350.

```python
from PIL import Image, ImageDraw, ImageFont
import os

# ---- fill these from the plan + branding ----
SLIDES = [
    # (headline, subline, kind)  kind = "cover" | "body" | "cta"
    ("YOUR HOOK HERE", "One supporting line.", "cover"),
]
BRAND = "#6C47FF"   # brand_color
MODE  = "dark"      # "dark" or "light"
# ---------------------------------------------

W, H, MARGIN = 1080, 1350, 96
BG, FG, MUTED = (("#0B0B0F", "#FFFFFF", "#9A9AB0") if MODE == "dark"
                 else ("#FFFFFF", "#0B0B0F", "#5A5A6E"))

def load_font(size, bold=True):
    candidates = [
        "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf" if bold
        else "/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf",
        "/usr/share/fonts/truetype/liberation/LiberationSans-Bold.ttf" if bold
        else "/usr/share/fonts/truetype/liberation/LiberationSans-Regular.ttf",
        "/System/Library/Fonts/Supplemental/Arial Bold.ttf" if bold
        else "/System/Library/Fonts/Supplemental/Arial.ttf",
    ]
    for p in candidates:
        if os.path.exists(p):
            return ImageFont.truetype(p, size)
    try:
        return ImageFont.load_default(size=size)
    except TypeError:
        return ImageFont.load_default()

def wrap(draw, text, font, max_w):
    words, lines, cur = text.split(), [], ""
    for w in words:
        t = (cur + " " + w).strip()
        if draw.textlength(t, font=font) <= max_w:
            cur = t
        else:
            if cur:
                lines.append(cur)
            cur = w
    if cur:
        lines.append(cur)
    return lines

def draw_slide(idx, total, headline, subline, kind):
    img = Image.new("RGB", (W, H), BG)
    d = ImageDraw.Draw(img)
    d.rectangle([0, 0, W, 14], fill=BRAND)              # top accent bar
    h_font = load_font(96 if kind != "body" else 84, bold=True)
    s_font = load_font(44, bold=False)
    max_w = W - 2 * MARGIN
    h_lines = wrap(d, headline.upper(), h_font, max_w)
    s_lines = wrap(d, subline, s_font, max_w) if subline else []
    line_h = h_font.size + 18
    sub_block = (s_font.size + 14) * len(s_lines)
    block_h = line_h * len(h_lines) + (40 + sub_block if s_lines else 0)
    y = (H - block_h) // 2
    if kind != "body":                                  # accent dot on cover/cta
        d.ellipse([MARGIN, y - 70, MARGIN + 36, y - 34], fill=BRAND)
    for ln in h_lines:
        d.text((MARGIN, y), ln, font=h_font, fill=FG)
        y += line_h
    if s_lines:
        y += 40
        for ln in s_lines:
            d.text((MARGIN, y), ln, font=s_font, fill=MUTED)
            y += s_font.size + 14
    pg = load_font(34, bold=True)
    d.text((MARGIN, H - 96), f"{idx:02d} / {total:02d}", font=pg, fill=BRAND)
    label = "SWIPE →" if idx < total else "SAVE"
    tw = d.textlength(label, font=pg)
    d.text((W - MARGIN - tw, H - 96), label, font=pg, fill=MUTED)
    fn = f"slide_{idx:02d}.png"
    img.save(fn)
    return fn

total = len(SLIDES)
files = [draw_slide(i + 1, total, h, s, k) for i, (h, s, k) in enumerate(SLIDES)]
print("Wrote", len(files), "slides at", f"{W}x{H}:", files)
```

## Step 3 — Deliver
- Confirm N PNG files were written at 1080×1350.
- Present every slide_XX.png as a downloadable file.
- Tell the user to download all of them and upload as one Instagram carousel, in
  numeric order.
- If the user wants a change, edit only that slide's text in SLIDES and re-render
  just that file.

Install it (and confirm it's live)

Skills work on Free, Pro, Max, Team, and Enterprise plans. They require code execution to be turned on — that's also what renders your PNGs.

Claude Code (terminal / IDE)

In Claude Code, skills live in a folder. Use the personal location to make it available in every project:

bashCopy
mkdir -p ~/.claude/skills/script-to-carousel

Then save the skill file from above into that folder as SKILL.md, so the full path is:

promptCopy
~/.claude/skills/script-to-carousel/SKILL.md

For a single project instead, use .claude/skills/script-to-carousel/SKILL.md inside that repo. Claude Code picks up skills automatically with live change detection — no restart needed.

Confirm it's active: open Claude Code and ask what skills are available?, or just paste a script and ask for a carousel. The skill fires when your request matches its description.

Claude Desktop and claude.ai (web)

1. Turn on code execution: Settings → Capabilities, enable Code execution / file creation.
2. Go to Customize → Skills (claude.ai/customize/skills).
3. Click to add a skill and upload your SKILL.md (or a folder/zip containing it).
4. Toggle the skill on.

Confirm it's active: it appears in your Skills list with the toggle enabled. Start a new chat, paste a script, and ask for a carousel — Claude will invoke it.

On Team and Enterprise plans an admin enables Skills and code execution once at the org level (Organization settings → Skills); after that you upload your own under Customize → Skills.

The input format: how to paste your script

The skill expects one thing: your script. You can paste it plain, or tag your branding on top. Here's the format that works every time:

promptCopy
Use the script-to-carousel skill.

Brand color: #6C47FF
Background: dark

Script:
<paste your full script here — paragraphs, talking points, or numbered steps>

What the skill does with it:

• Length: any length works. Short scripts make ~6 slides, longer ones up to ~9. It won't pad with filler or cram everything onto one slide.
• Structure: the strongest line becomes the cover. Each idea (or numbered step) becomes its own body slide, in your original order. The closing line becomes the CTA slide.
• Rewriting: it tightens each line into a headline plus a short supporting line. It won't add facts that aren't in your script.

Before rendering, it prints a slide-by-slide plan so you can approve or tweak the split first.

Add your branding (optional)

Branding is optional. Skip it and you still get clean, post-ready slides on the default dark theme with a purple accent.

To make it yours, add any of these above your script:

promptCopy
Brand color: #FF5A1F      ← any hex; becomes the accent bar, dot, and page numbers
Background: light          ← "dark" or "light"
Style notes: bold sans, lots of contrast, punchy

• Brand color drives the top bar, the cover accent dot, and the page counter.
• Background flips the whole deck between dark and light (text color adjusts automatically).
• Style notes guide tone and emphasis.

If you skip all of it, the defaults are #6C47FF accent on a dark background — already clean enough to ship.

Want exact brand fonts? Upload a .ttf file to the chat and tell Claude to use it — then point the renderer's load_font list at that file path. Without a custom font, it uses a crisp default sans.

Get your slides and post them

When rendering finishes, you'll have files named slide_01.png, slide_02.png, and so on — each one 1080×1350, which is Instagram's exact portrait carousel size.

To download and post:

1. Download every slide_XX.png. In claude.ai/Desktop each file shows a download button; in Claude Code they're written to your working folder.
2. Open the Instagram app and tap + → Post.
3. Tap the multiple-select (layers) icon and pick all your slides in numeric order (01, 02, 03 …).
4. Instagram keeps them at 1080×1350 — no cropping needed.
5. Write your caption, add the CTA, and post.

That's the whole loop: paste a script, download the PNGs, upload the carousel.

Worked example: script in → slides out

The script you paste:

promptCopy
If you write video scripts but never turn them into posts, you're leaving reach
on the table. Here's the fix.

First, write your script like you normally would. Then hand it to Claude with
this skill installed. It splits your script into slides and builds each one for
you. You download them and post.

No Canva, no designer, no code. The whole thing takes about five seconds.

Want to try it? Comment CAROUSEL and I'll send you the skill.

The slide breakdown it returns (before rendering):

promptCopy
Slide 1 (cover): STOP LETTING SCRIPTS DIE IN A DOC
                 Every script you write is a carousel you haven't posted yet.

Slide 2 (body):  WRITE YOUR SCRIPT LIKE NORMAL
                 No new format — use the script you'd film anyway.

Slide 3 (body):  HAND IT TO CLAUDE
                 With the skill installed, paste your script. That's the input.

Slide 4 (body):  IT BUILDS EVERY SLIDE
                 Claude splits your script and renders each slide for you.

Slide 5 (body):  DOWNLOAD AND POST
                 No Canva, no designer, no code.

Slide 6 (cta):   WANT THE SKILL?
                 Comment CAROUSEL and I'll send it over.

Approve the plan and it renders six slide_0X.png files at 1080×1350, ready to download. Six lines of script became a finished carousel.

Requirements and troubleshooting

Requirements

• Any Claude plan: Free, Pro, Max, Team, or Enterprise.
• Code execution enabled (Settings → Capabilities) — required for skills and for rendering the PNGs.
• In Claude Code, skills run in beta and are auto-discovered from your skills folder.
• Pillow (the Python image library) is available in the code-execution sandbox — no install needed.

Common issues

• Skill never fires. On claude.ai, confirm the toggle is on under Customize → Skills. In Claude Code, confirm the file is at ~/.claude/skills/script-to-carousel/SKILL.md. Then say use the script-to-carousel skill explicitly.
• "Code execution is not enabled." Turn it on in Settings → Capabilities, then retry.
• Text overflows a slide. Your line was too long. Ask shorten slide 4 or trim that line in your script — the renderer wraps text but very long single lines still read better short.
• Fonts look plain. The sandbox uses a default sans. Upload a .ttf and tell Claude to use it for exact brand type.
• Regenerate one slide. Say regenerate slide 3 with the headline "HAND IT TO CLAUDE". Only that PNG re-renders — the rest stay untouched.

FAQ

Do I need a paid Claude plan? No. Skills work on Free, Pro, Max, Team, and Enterprise. The only requirement is that code execution is enabled in your settings, which is also what renders the slides.

Will the slides match my exact brand fonts? Out of the box they use a clean default sans plus your accent color. For exact fonts, upload a .ttf to the chat and tell Claude to point the renderer's load_font list at it — the rest of the layout stays the same.

Can I edit a slide after it's generated? Yes. Ask Claude to regenerate just that slide with new text. It changes only that one PNG and leaves the rest of your carousel exactly as it was.