Cross Platform Repurposing

Use to turn one piece of content into multiple platform-native posts — adapt, never copy-paste. Run when the user says "repurpose this," "turn this into posts for every platform," "cross-post," "make this work on TikTok/LinkedIn/X too," "one idea into a week of content," "turn this blog/video/podcast into social posts," or wants to fan content out. Reads brand-profile and voice first, extracts the core idea, then re-natives it for each platform (different hook, format, length, mechanics, CTA) using the content skills, and hands the fan-out to scheduling-and-queue. This is the multiplier that makes a content operation sustainable — but every version must stand on its own and feel native, never duplicated.

This skill turns one idea into many posts — the single biggest lever for producing content sustainably. One blog post becomes a week of social; one strong insight becomes five platform-native posts. It's how a small team posts like a big one.

The principle that makes it work — and the trap that ruins most attempts:

Repurposing is not reposting. Pasting the same caption onto every platform is the lazy version: it fits none of them natively, it looks like spam to anyone who follows you in two places, and several platforms quietly suppress obviously cross-posted content. The craft is atomize → adapt: extract the core idea, then rebuild it natively for each target — a different hook, format, length, and CTA, same truth and voice.

When to use this

• Fan one post out across platforms (one → many).
• Atomize a long piece (blog, video, podcast, newsletter) into many short posts (long → short).
• Convert one format into others (a written insight → a carousel, a Reel, a thread).
• Inside batch-content-plan, to stretch limited raw material into a full calendar.

When NOT to use it: when content is genuinely platform-specific (an in-joke, a platform-native trend, a reply) — forcing it elsewhere reads wrong. And when the audience overlaps almost entirely on two platforms, vary the angle, don't just relocate the post. Know when a piece shouldn't travel.

Step 0 — Read the foundation first

Load brand-profile.md and voice.md. Voice stays constant across platforms; register shifts per platform (use the voice tone-map — LinkedIn more formal, TikTok looser). Carry guardrails everywhere.

Step 1 — Atomize: find the core idea

Extract the reusable atom from the source — the point, the insight, the story, the stat, the moment. For a single post that's usually one atom; for long-form (a blog, a 20-minute video) it's several atoms, each strong enough to be its own post. Don't summarize a long piece into one weak post — pull its best 5–10 atoms. See references/repurposing-model.md.

Step 2 — Pick targets and direction

Decide the platforms and the direction of the repurpose (one→many, long→short, format→format, video↔text — see references/source-types.md). Direction determines the mechanics.

Step 3 — Re-native per platform (don't translate, rebuild)

For each target, rebuild the atom natively — composing the right skills:

• A new hook per platform (hook-writer) — what hooks on a LinkedIn feed differs from a TikTok first frame.
• The right format and length for that platform.
• The copy (caption-writer), the script if video (reels-script), or the thread (thread-writer).
• Native mechanics — hashtags, links (bio vs clickable vs comments), CTA.

What stays the same: the atom and the voice. What changes: hook, format, length, structure, CTA, mechanics, register. See references/platform-transforms.md.

Step 4 — Quality-check: does each stand alone and feel native?

Every version must pass two tests:

1. Stands alone — someone who only sees this one post gets full value (no "as I said on LinkedIn…").
2. Feels native — it looks built for this platform, not relocated. If you can tell it was copy-pasted, rebuild it.

If two platforms share most of the audience, change the angle between them, not just the formatting.

Step 5 — Hand off to scheduling

Pass the finished, per-platform versions to scheduling-and-queue to schedule/fan out (it confirms and validates first; WoopSocial applies per-platform fields). Space them out — don't fire the same idea everywhere at the same minute.

Quality bar — self-check

• Did you atomize (extract the core idea) rather than translate the wrapper?
• Is each version genuinely native — different hook, format, length, CTA — not copy-paste?
• Does each stand on its own?
• Is the voice constant with the register shifted per platform?
• For long-form, did you pull multiple atoms, not one summary?
• Did you recognize anything that shouldn't be repurposed?

If two versions are the same text with different hashtags, you reposted — go back to Step 3.

Edge cases

• Heavy audience overlap across platforms → vary the angle/format between them so followers don't see the same post twice.
• Platform-specific content (trends, replies, in-jokes) → don't force it elsewhere; say so.
• Long-form with one idea → it's one atom; don't manufacture filler to hit a post count.
• Video → text → pull the spoken insights/quotes as written atoms; don't just transcribe.
• Text → video → hand the atom to reels-script to build it as a video, don't read the caption aloud.
• Regulated/sensitive → carry compliance guardrails into every version.

Related skills

• brand-profile, voice-builder — voice + register + guardrails.
• hook-writer — a fresh hook for each platform.
• caption-writer, reels-script, thread-writer — build each native version.
• content-recycling — repurposing across time (refresh evergreen later).
• captions-and-clipping, opus-clip — cutting clips from long video (podcasts, webinars) at depth.
• batch-content-plan — uses this to stretch material into a calendar.
• scheduling-and-queue — schedules/fans out the finished versions.

References

• references/repurposing-model.md — atomize → adapt; what stays vs changes; the directions.
• references/platform-transforms.md — how one idea becomes each platform's native post.
• references/source-types.md — repurposing by source/direction (long-form, fan-out, cross-medium).
• references/examples.md — one idea → five native versions, and a long-form atomization.