Building a Content Repurposing Agent With Claude Code

A content repurposing agent is one of the highest-leverage things you can build in Claude Code, because repurposing is mostly mechanical: find the good parts of a long asset, reformat them per platform, and ship them on a schedule. This guide walks through building a content repurposing agent with Claude Code from scratch: the folder layout, the workflow, the platform playbooks, the skills, the quality gates, and the publish step. Every publishing command below is a real Creator OS CLI command, so nothing here is theoretical.

source.md  (one long asset: video transcript, essay, podcast notes)
    |
    v
[ 1. fetch  ]  read source, strip filler, keep facts
    |
    v
[ 2. chunk  ]  split into 5-12 self-contained beats
    |
    v
[ 3. rewrite ]  playbook per platform: threads, carousels,
    |            Shorts scripts, email teasers
    v
[ 4. store  ]  /outputs/<slug>/threads.md, shorts.md, ...
    |
    v
[ 5. gate   ]  voice check, fact check, human approve
    |
    v
[ 6. publish ]  creatoros posts:bulk-upload --file calendar.json

One source asset in, six platform-ready asset sets out.

What a Content Repurposing Agent Actually Does (and Why It Beats Manual Repurposing)

Manual repurposing has a predictable failure mode: you do it once, well, for the platform you care about most, then the other platforms go quiet. An agent flips that. You give it a long asset (a 40 minute video transcript, a 3,000 word essay, podcast notes) and it produces a batch of platform-native pieces in one pass, then hands you a calendar to approve.

The agent is not a summarizer. A summarizer shortens. A repurposing agent does four jobs: it extracts the beats that stand alone, it rewrites each beat for the platform’s format and length, it preserves the specific claims so nothing drifts, and it produces a schedule you can push to your accounts. If you have already built a posting agent, this is the upstream half: see how to build a social media agent with Claude Code for the publishing side.

Claude Code is a good fit for this because the work is file-shaped. Source files in, markdown out, a JSON calendar in between. Claude Code reads and writes files, runs shell commands, and can call your Creator OS account through the hosted MCP server or the CLI. You get a pipeline you can inspect and diff, not a black box.

Get started for $0

Prerequisites: CLAUDE.md, Folder Structure, and Your Single Source Asset

Set up three things before you write a single prompt.

1. A CLAUDE.md at the repo root. Claude Code reads this on every session. Keep it short and operational: what the repo is for, where sources live, where outputs go, which voice rules apply, and which commands it may run without asking.

# Repurposing agent

## Layout
- /sources/      raw transcripts and drafts (never edited)
- /outputs/      generated assets, one folder per source slug
- /playbooks/    one markdown file per platform format
- /state/        calendar.json, fact-check notes

## Rules
- Never invent facts, numbers, names or quotes.
- Every claim in an output must trace to a line in the source.
- Write in second person, short sentences, no hype adjectives.
- Draft only. Do not publish without my approval in /state/approved.md.

## Commands allowed without asking
- creatoros validate:post-length, creatoros validate:media,
  creatoros analytics:posts, creatoros posts:bulk-upload

2. A folder structure that separates inputs from outputs. Never let the agent edit a source file. If outputs live in their own tree keyed by slug, you can rerun the pipeline after a playbook change and compare.

3. One source asset, cleaned. Save the transcript or draft to /sources/. Before the agent runs, strip timestamps and speaker labels into a plain paragraph file. This one step removes most of the garbage the agent would otherwise carry into the rewrites.

Connect your accounts once so the publish step later has somewhere to go:

creatoros auth:check
creatoros accounts:list
creatoros accounts:health

If accounts:health shows a stale connection, run creatoros accounts:connect instagram (or the platform that needs it) before you build the calendar, not after.

Design the Agent’s Repurposing Workflow: Fetch, Chunk, Rewrite, Store

Describe the pipeline in plain language in a skill file, then let Claude Code execute it step by step. The four steps matter because each one fails differently.

Fetch. Read the source. Produce a /outputs/<slug>/00-beats.md file: a numbered list of every self-contained idea, with a short verbatim quote for each. No rewriting yet. This is your audit trail for fact preservation later.

Chunk. Group beats into 5 to 12 clusters. Each cluster becomes one repurposable unit. A cluster is the wrong size if it needs the previous paragraph to make sense. Ask the agent to name each cluster in under eight words.

Rewrite. For each cluster, run the matching playbook. One cluster can feed a thread, a carousel, a Shorts script and an email teaser, but each output is written independently from the beat, not from the other outputs. This prevents the “same post everywhere” smell.

Store. Write each output to a named file: threads.md, carousel.md, shorts.md, email.md, plus a calendar.json that maps outputs to platforms and dates.

Here is the prompt that drives the whole run. Save it as /playbooks/run.md:

Read /sources/<slug>.md. Follow CLAUDE.md.

Step 1: write /outputs/<slug>/00-beats.md with 10 to 20 numbered
beats. Each beat: one sentence summary plus one verbatim quote.

Step 2: cluster the beats into 5 to 12 groups. Write the cluster
list to /outputs/<slug>/01-clusters.md.

Step 3: for each cluster, apply /playbooks/threads.md,
/playbooks/carousel.md, /playbooks/shorts.md and
/playbooks/email.md. Skip a playbook if the cluster does not
support it. Write one file per format per cluster.

Step 4: build /state/calendar.json. Spread posts over 14 days,
one piece per platform per day maximum. Use ISO dates and the
timezone America/Toronto.

Then validate every caption:
creatoros validate:post-length --text "<caption>"
Report anything that fails. Do not publish.

Write Platform Playbooks: Threads, Carousels, Shorts Scripts, and Email Teasers

The playbooks are where the quality actually lives. Each one is a short markdown file with format rules, a length ceiling, and a required shape. Write them yourself once, and the agent applies them consistently forever.

Threads (X and Threads)

Post 1 is the claim, under 200 characters, no throat clearing.
Each follow-up makes one point and ends with forward pull.
Threads posts cap at 500 characters. Ask the agent to stay under 450.
No hashtags beyond one, no links in the first two posts.

If your source is video, the transcript is already conversational, so threads write themselves. The launch video shows the shape of these agent workflows end to end, which is useful before you write your first playbook.

Carousels (Instagram)

Six to nine cards. Card one is a hook, card last is a single call to action.
One idea per card, ten words maximum on the visual.
Put supporting detail in the caption, not the card.
Keep the caption’s link in the first comment; Instagram captions have no clickable links.

Shorts scripts (YouTube Shorts, TikTok, Reels)

Hook in the first two seconds, spoken.
Total 45 to 60 seconds, roughly 120 to 160 words.
Write it as spoken lines, not prose. Mark the b-roll beat in brackets.
No trend audio direction; the API cannot attach trending audio, so sound has to be baked into the file.

For the edit itself, the one-line launch video skill covers turning a script into a rendered clip, and OPEN VIDEO EDIT (github.com/kevinbadi/open-edits) turns a raw talking-head clip into an animated short with captions and b-roll cards, rendering locally with Python and ffmpeg. A repurposing agent plus that skill closes the loop from transcript to published Short without a timeline app.

Email teasers

Subject line under 45 characters, no colons, no emoji.
Body: 60 to 90 words, one link, plain text.
Open with the strongest beat, close with the specific thing they get by clicking.

Wire the Agent Into Claude Code With Skills and Subagents

Two mechanisms do the work: skills (reusable instruction bundles) and subagents (separate contexts for heavy reads).

Install the Creator OS skills so the agent already knows how to talk to your accounts:

npx @creatoros/cli@latest init

That installs 14 Claude Code skills, including post-everywhere, post-threads, post-shortform, schedule-posts, analytics and automations, plus CLI helpers for length and media checks. Later, creatoros sync updates those skills without overwriting the ones you have edited: your files stay as they are, and each updated skill arrives alongside as a .new file you can diff against and merge by hand. That matters here, because the skills are the part of the pipeline you are most likely to tune.

For the repurposing pipeline itself, add a custom skill at .claude/skills/repurpose/SKILL.md that points at your /playbooks/ folder and /playbooks/run.md. Now “repurpose this source” is one phrase.

Use a subagent for the fetch and chunk steps. Reading a 40 minute transcript burns context you want for rewriting. Tell Claude Code to run those two steps in a subagent and return only 00-beats.md and 01-clusters.md. The main session then rewrites with a clean window.

If you would rather have the accounts reachable as tools instead of shell commands, connect the hosted MCP server. For Claude Code:

claude mcp add --transport http creatoros https://mcp.creatoros.ca/mcp --header "Authorization: Bearer cos_live_..."

Read-only connections only see read tools and the API refuses writes from them, which is a good default while you are still tuning playbooks. The MCP docs cover the Claude, ChatGPT, Cursor, Windsurf and VS Code setups.

Add Quality Gates: Voice Checks, Fact Preservation, and Human Review

This is the section people skip and then regret. Three gates, all cheap.

Voice check. Keep a /playbooks/voice.md with five to ten rules and a list of banned words. Have the agent run a self-review pass that outputs a table: asset file, rule violated, line number. Anything flagged either gets rewritten or deleted. Do not let the agent grade its own writing as “good”; force it to name specific violations.

Fact preservation. Diff every output against 00-beats.md. Any number, name, date or claim in an output that does not appear in the beats file is a fabrication. Ask for a line-by-line trace in /state/factcheck.md. This is the single highest-value step in the whole pipeline, because a repurposed post that invents a statistic does real damage.

Human review. The agent stops at a checklist. You read the outputs, tick them off in /state/approved.md, and only then does the publish step run. Enforce it in CLAUDE.md: publishing commands require that file to exist and to list the approved slugs.

One more gate that costs nothing: length. Run creatoros validate:post-length --text "<caption>" on every generated caption before it enters the calendar, and creatoros validate:media --url <url> on any media you reference. Catching a 300 character X post at generation time beats catching it at publish time.

Automate Scheduling and Publishing to Close the Loop

The calendar file is the handoff. creatoros posts:bulk-upload --file <calendar.json> [--dryRun] takes a JSON calendar and creates the posts. Run it with --dryRun first, every single time, and read the report.

For a single piece, the direct route is clearer:

creatoros posts:create --text "<caption>" --platforms instagram,tiktok,youtube --media <med_id_or_url> --scheduledAt 2026-03-04T14:00:00Z --timezone America/Toronto

Two behaviours to know. Upload media once with creatoros media:upload <file> and reuse the returned med_ id on every platform. And if the calendar names a platform you have not connected, that platform comes back in missing_platforms while the rest still go out. The post options docs list what each platform accepts, including Reels covers, TikTok consent flags and YouTube visibility.

For a fully hands-off loop, create an automation that reruns the pipeline weekly and posts into a slot you have already approved, then check creatoros analytics:posts --sortBy engagement to see which repurposed formats earned attention. The content calendar automation guide goes deeper on the scheduling layer, and Social Agents is an open-source harness you can start with npm start creatoros social-agents if you want a running agent rather than a script you maintain.

Test, Measure, and Iterate on Repurposing Output Quality

Treat each playbook as a versioned experiment. Three habits make the loop work.

Keep a golden set. Five source assets and the outputs you consider best. After any playbook edit, rerun and diff. If the golden set gets worse, revert.
Measure by format, not by account. Pull creatoros analytics:posts --from 2026-02-01 --to 2026-03-01 --platform instagram --sortBy engagement and compare carousels to single images from the same source. Formats differ more than platforms do.
Check timing with data. creatoros analytics:best-time --platform tiktok gives you the slots the calendar should target instead of the guessed ones in your prompt.

When a format underperforms for two cycles, the playbook is usually the problem, not the source. Tighten the hook rule and rerun the same source. That is the whole advantage of having the pipeline in files: the improvement is a diff, and the next 20 posts inherit it.

Get Started With Creator OS

You can run the whole pipeline on the Creator plan at $14.99/month or $59.99/year, which covers 11 platforms plus Skool, one account on each. API keys, the MCP server, the CLI and the agent skills are included in every plan, and the ads add-on is $19.99/month with no percentage of ad spend if you later want to boost the repurposed posts.

Sign up at creatoros.ca/sign-up, install the CLI, and read the docs for the base URL and request shapes when you move from the CLI to raw HTTP. Then watch the walkthroughs on the KevBuildsApps YouTube channel and build the first version of your repurposing agent this afternoon: one source file, four playbooks, one calendar.

Get started for $0
Free trial for new subscribers. Cancel anytime.