/cross-platform-repurposing

name: cross-platform-repurposing
description: >-
  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.
metadata:
  version: 1.0.0
license: MIT

Cross-Platform Repurposing

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`