Twitter Thread to Carousel With Claude: The Exact 5-Step Setup (Files + Prompts to Copy)

Carousels are the highest-engagement format on Instagram and LinkedIn right now. They get roughly 1.4× the reach of single-image posts and consistently beat every other post type for content creators sharing ideas or step-by-steps.

If you write threads on X or have ideas worth sharing visually, a twitter thread to carousel conversion is the single highest-leverage repurposing move you can make in 2026.

Using AI to generate these carousels makes the design step disappear entirely. What used to take 30 minutes in Canva now takes 5 minutes in a single Claude chat.

This guide gives you the exact twitter thread to carousel setup — the files to upload, the instructions to paste, the skill you need (with its full SKILL.md), and the exact prompts.

Even if you’re not particularly AI- or tech-friendly, you can copy-paste your way through this in under 10 minutes.

Twitter Thread to Carousel

A twitter thread to carousel is exactly what it sounds like. You take the text from a Twitter (X) thread and turn it into a stack of Instagram-ready image slides.

Every slide is styled to look like a tweet: clean white background, profile header with handle and verified badge, body text, progress bar at the bottom. Same brand layout every time.

Here’s the end-to-end flow at a glance:

You don’t actually need a Twitter thread to start

The most useful thing about this twitter thread to carousel system: it isn’t limited to actual threads. The name describes the most common use case, not the only one.

You can feed Claude any of these and get the same tweet-style carousel output:

Whether the input is a real thread or just a topic, every slide carries the same tweet header so the carousel reads like a thread visually. Slide 1 is the hook. Slides 2–6 are the steps. The last slide closes with a CTA.

Why Can’t You Just Use an AI Carousel Maker?

You absolutely can. There are dozens of AI carousel maker tools out there — AI carousel generators, AI Instagram carousel makers, “free” AI carousel apps. I tried a handful before settling on the twitter thread to carousel setup in this guide.

Here are the issues I ran into with most AI carousel maker tools, in the order I noticed them:

Twitter Thread to Carousel With Claude

The full setup is 5 steps and takes 10 minutes once. After that, every twitter thread to carousel run is 3 prompts and 5 minutes.

New to Claude Projects? Here’s the 30-second explainer

A Claude Project is basically a folder inside Claude where everything for one specific job lives. For our twitter thread to carousel setup, the “specific job” is making carousels. Each project has these things you can set up:

• Name — what you call it (e.g., “Instagram Carousel Generator”)
• Instructions — the rules Claude follows in every chat (you paste the brand layout rules here)
• Files — uploads every chat can see (your profile photo goes here)
• Skills — small reusable code modules (the PNG export logic lives here)
• Chats — actual conversations. Each new carousel = a new chat inside this same project

All of this lives in one place: go to claude.ai and click Projects in the left sidebar.

The 5 steps below fill in Name, Instructions, Files, and Skills once. After that, you just open new chats inside the same project to make carousels — Claude carries the brand layout and the export skill across every twitter thread to carousel run automatically.

Before you start, you need:

Go to claude.ai, click Projects in the left sidebar, then New project.

Name it “Instagram Carousel Generator” (or anything your brand prefers). The description doesn’t matter — anything works.

Drag your square profile photo into the Files section of the project. The filename doesn’t matter.

Claude will embed this photo as base64 into every slide of every twitter thread to carousel you generate.

Click the Copy button on the box below, then paste the contents into the Project instructions field of your new Claude project.

Only edit the 5 lines marked in the table after this box — leave everything else alone.

You are an Instagram carousel design system. When the user asks to create a carousel, generate a fully self-contained, swipeable HTML carousel where every slide is exported as an individual 1080×1350px PNG for Instagram posting.

BRAND DETAILS (EDIT THESE 5 LINES)
- Brand name: [YOUR BRAND NAME]
- Instagram handle: @[your-handle]
- Display name: [Your Display Name]
- Tone: Casual
- Accent color: #2FAD64

BRAND COLORS (defaults — edit if needed)
- Text dark: #0f1419 (bold headlines)
- Text body: #333333 (regular body text)
- Handle color: #536471 (@handle under display name)
- Background: #FFFFFF (pure white)

FONT
Plus Jakarta Sans (weights 300–700) via Google Fonts.

PROFILE PHOTO
Use the circular profile photo uploaded to this project's files. Encode it as base64 and embed it directly in the HTML so the carousel is fully self-contained.

WORKFLOW
1. Ask the user three things: topic, slide count (default 7), and any specific content to include.
2. Generate a self-contained HTML carousel with a swipeable Instagram-frame preview wrapper. All slides at 420×525px (4:5 ratio). Embed the profile photo as base64. Load Google Fonts via CDN.
3. If the user wants changes, update only the requested slides. Don't rebuild from scratch.
4. When approved, use the carousel-to-png skill to export each slide as 1080×1350px PNG.

TWEET-STYLE DESIGN RULES
- Background: pure white #FFFFFF on every slide
- Profile section: 48px circular headshot + display name (bold, 15px) + verified badge SVG + @handle (14px, handle color)
- Bold headline: 17px, weight 700, dark text
- Body: 15px, weight 400, body text color, line-height 1.55
- Accent text: 15px, weight 700, accent color — for hooks, CTAs, key lines
- Use → arrows for lists, not bullets
- Content padding: 0 36px 52px (clears progress bar)
- Vertical alignment: justify-content: center

NARRATIVE STRUCTURE
- Slide 1: Hook in accent color + a teaser line
- Slides 2 through (N-1): One step per slide ("Step N: [Title]") + body + → arrows for lists
- Last slide: Recap result + CTA in accent color

ELEMENTS ON EVERY SLIDE
- Progress bar at bottom: 3px track, accent-color fill, counter "1/7" in 11px
- Swipe arrow on right (48px gradient fade + chevron) — remove on last slide
- Same tweet header on every slide

INSTAGRAM FRAME (PREVIEW WRAPPER)
- Frame width: exactly 420px (do NOT change)
- Header: avatar + handle + display name
- Viewport: 4:5 aspect ratio (420×525), pointer-drag with snap-to-slide
- Dots indicator below viewport

EXPORT
- Use the carousel-to-png skill — do not write your own export script
- Always use Python for HTML manipulation, never shell scripts ($ interpolation corrupts HTML)
- Embed images as base64 data URIs
- Verify final PNGs are exactly 1080×1350px before presenting them

The five lines to edit before you save:

Hit Save on the project instructions when done.

The skill handles the PNG export at Instagram’s exact resolution. Inside your Claude Project, go to Skills, click New skill, name it carousel-to-png, and paste the SKILL.md content below.

# Carousel to PNG Exporter

Export each slide of an HTML carousel as a 1080×1350px PNG, ready to post on Instagram.

## When to use this skill
Trigger when the user has an approved HTML carousel and asks to "export carousel", "export slides", "save as PNG", or "convert to images".

## Two rules that make or break the export

### Rule 1 — Embed fonts as base64 BEFORE exporting
If the HTML loads Google Fonts via <link>, headless Chrome may render with a fallback font. Embedding WOFF2 files as base64 in the HTML eliminates this.

### Rule 2 — Screenshot the slide element, NOT the page with a clip rectangle
page.screenshot({clip:...}) has subpixel rounding issues at fractional scale factors. element.screenshot() is pixel-perfect.

## Prerequisites
pip install playwright --break-system-packages
playwright install chromium

## Step 1 — Embed the fonts
```python
import base64, re, urllib.request
from pathlib import Path

GOOGLE_FONTS_URL = "https://fonts.googleapis.com/css2?family=Plus+Jakarta+Sans:wght@300;400;500;600;700&display=swap"
HTML_PATH = Path("/path/to/carousel.html")
UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/131.0.0.0 Safari/537.36"

def fetch_embedded_fonts_css(fonts_url):
    req = urllib.request.Request(fonts_url, headers={"User-Agent": UA})
    css = urllib.request.urlopen(req).read().decode("utf-8")
    for font_url in set(re.findall(r"url\((https://[^)]+\.woff2)\)", css)):
        data = urllib.request.urlopen(font_url).read()
        b64 = base64.b64encode(data).decode("ascii")
        css = css.replace(font_url, f"data:font/woff2;base64,{b64}")
    return css.replace("font-display: swap;", "font-display: block;")

embedded_css = fetch_embedded_fonts_css(GOOGLE_FONTS_URL)
html = HTML_PATH.read_text(encoding="utf-8")
html = re.sub(r'<link[^>]*fonts\.googleapis\.com[^>]*>', f"<style>{embedded_css}</style>", html)
HTML_PATH.write_text(html, encoding="utf-8")
```

## Step 2 — Export each slide as PNG
```python
import asyncio
from pathlib import Path
from playwright.async_api import async_playwright

INPUT_HTML = Path("/path/to/carousel.html")
OUTPUT_DIR = Path("/path/to/slides")
OUTPUT_DIR.mkdir(exist_ok=True)

SLIDE_W, SLIDE_H = 420, 525
SCALE = 1080 / SLIDE_W

async def export_slides():
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page(
            viewport={"width": SLIDE_W + 400, "height": SLIDE_H + 400},
            device_scale_factor=SCALE,
        )
        await page.set_content(INPUT_HTML.read_text(encoding="utf-8"), wait_until="networkidle")
        await page.evaluate("() => document.fonts.ready")
        await page.wait_for_timeout(3000)
        slides = await page.query_selector_all(".slide")
        for i, slide in enumerate(slides):
            await slide.screenshot(path=str(OUTPUT_DIR / f"slide_{i+1:02d}.png"))
        await browser.close()

asyncio.run(export_slides())
```

## Key rules
1. Embed fonts as base64 BEFORE export
2. Viewport = slide_width + 400 (buffer)
3. element.screenshot(), not page.screenshot({clip})
4. device_scale_factor to scale up
5. Wait for document.fonts.ready + 3 seconds
6. Use Python, never shell scripts

Your Claude Project is now fully configured for twitter thread to carousel work. Here’s how to actually use it to make a carousel:

1. Open claude.ai and click your project name in the left sidebar.
2. Inside the project, click + New chat (not a regular chat at the top — the project context is what makes this work).
3. Paste the three prompts below into that chat, one at a time. Change the parts marked in brackets [ ] to your own content.

That’s it. Every twitter thread to carousel job from now on is these three prompts in order.

Prompt 1 — Convert your thread (or topic) into a carousel:

Turn this into a twitter-style carousel — 7 slides.

Here's the thread:

[PASTE YOUR THREAD HERE]

If you don’t have a thread, replace the bracketed section with a topic instead — e.g., “Topic: 7 productivity habits for solopreneurs. Make each slide one habit.”

Swipe through every slide. If anything needs to change (a slide is too long, the hook is weak, you want to split a slide into two), use Prompt 2. If it looks good, skip to Prompt 3.

Prompt 2 — Fix specific slides without losing the rest:

Slide 3 needs to be punchier and break into two slides. Only update slide 3 — don't rebuild the rest.

The “don’t rebuild the rest” line is what stops Claude from regenerating the whole carousel and losing your other edits.

Prompt 3 — Export as PNGs:

Use the carousel-to-png skill to export all slides as 1080×1350 PNGs.

Click “Download” on each PNG to save it to your computer. Save them in numbered order (slide_01 first) so they go into Instagram in the right sequence.

Then drag the PNGs into the Instagram app in order, write your caption, and post. That’s a complete twitter thread to carousel run, start to finish.

For a wider library of reliable prompt patterns, our roundup of the best ChatGPT prompts for work and productivity uses the same Role + Context + Task + Format structure that makes these three prompts work consistently.

Who This Setup Is For (And How It Helps You Grow)

This twitter thread to carousel setup is built for people who already write — threads, newsletters, blog drafts, voice notes — and want a second-platform format without spending an hour in a design tool for every post.

If you publish a twitter thread to carousel run more than once a week, this setup pays for itself in time saved in the first month.

The growth and income math

For a broader view of monetization paths around AI workflows, our guide to 25 real ways to make money with AI covers content repurposing services in more depth.

What the Daily Workflow Looks Like

Once setup is done, here’s the actual minute-by-minute flow for a single twitter thread to carousel run:

Common Mistakes That Break the Twitter Thread to Carousel Export

Most twitter thread to carousel failures trace back to one of these five issues:

Variations You Can Try

The default produces tweet-style Instagram carousels. The same twitter thread to carousel architecture flexes to other formats:

If you’re still deciding which AI to anchor your content stack around, our breakdown of ChatGPT vs Claude vs Gemini walks through where each one wins for content work.

Claude’s Projects + Skills combo is the reason this specific twitter thread to carousel setup is possible without juggling external tools — neither ChatGPT nor Gemini ships an equivalent twitter thread to carousel pipeline today.

FAQ – Twitter Thread to Carousel With Claude