The Loop: Turning One Blog Post into a Week of Social Posts

Welcome to The Loop. Every Wednesday we take one real, repetitive workflow that someone does by hand and unwind it into something you can run. This week it's the afternoon that quietly disappears after you publish, when the hard part is already done and you're still typing.

Here's the reframe. The repurposing pass feels like writing, so it gets treated like writing: creative, unpredictable, yours. Watch yourself do it and something else shows up. You always pull the same kind of line for the hook. You always cut the same kind of caveat for the short version. You always end the LinkedIn one with a question and the newsletter one with a link. Those are rules. You've never written them down because you've never needed to say them out loud. Say them out loud once and they become a spec. Describing replaces doing.

So let's watch the repurposing loop run at full speed, price it honestly, and turn it into something that drafts next week's set while you're doing something better.

The Loop, in Full

You can't automate a loop you haven't watched closely, so here it is start to finish. It's Tuesday, mid-morning, at a forty-person software company.

Marcus runs marketing there, which in a company that size means he runs everything with a headline in it. The post went live twenty minutes ago: eighteen hundred words on how their customers cut onboarding time, three customer quotes, one chart. He's proud of it. Now he opens a blank doc and starts the part nobody warned him about. LinkedIn first, because it performs best, so he hunts back through his own article for the line that makes someone stop scrolling, rewrites it three ways, picks the second one. Then the thread, which means cutting the same argument into five beats that each survive alone. Then the newsletter blurb, shorter and warmer, with the link at the end. Then two captions for the design contractor. Then he schedules all of it, one platform at a time. It's two forty in the afternoon. He has not written a new sentence since eleven.

Written out as steps, the by-hand version looks like this:

1. Reread your own post and pull the three or four ideas strong enough to stand on their own.
2. For each channel, rewrite the chosen idea to that channel's length, tone, and opening convention.
3. Add the channel furniture: the hook, the line breaks, the hashtags, the call to action, the link placement.
4. Check it against your own voice and cut whatever sounds like a press release.
5. Schedule each piece into its own tool, spread across the next seven days.

Nothing there is hard. That's the tell. This is the shape of work you can hand off and it's exactly what it looks like to automate the publishing steps content managers repeat after every single piece. Hard work needs a decision nobody has made yet. This work needs you to apply decisions you made months ago, over and over, until the good idea you published has been retyped into four boxes.

The Manual Tax

The cost of a loop is never the clock alone. It's the hours, plus the quality that erodes when those hours run out, plus the reach you lose while the work waits in a doc. Add those together and you get the manual tax.

The pressure behind it is well documented. In the Content Marketing Institute's 2026 B2B research, 39 percent of marketers named resource constraints (time, people, budget) as one of their top three challenges, and 28 percent said they can't create enough quality content to meet what the organization needs. Read those two together and the picture is plain: the team isn't short on ideas, it's short on the hours between having one and getting it in front of people.

Then there are the two costs hiding underneath the hours:

• Errors. Not typos. Attrition. The fifth version of anything is worse than the first, and it's the one that goes to your largest audience. By the time Marcus writes the captions he's picking whatever's nearest, and the sharpest line in the piece never leaves the blog.
• Latency. Most repurposing that gets skipped isn't skipped on purpose, it just never gets done. The post goes out, the week gets loud, and four channels never hear about it. That's a piece of work paid for in full and shipped at a fraction of its reach, which is the first thing that changes when you automate the social queue that keeps running dry.

Nobody quits repurposing because it's hard. They quit because it's the fourth hour of a job that stopped being interesting after the first.

Which reframes the goal. You're not trying to save an afternoon, though you'll save it. You're trying to make sure the tenth post of the quarter gets the same distribution as the first, when the novelty is long gone and the calendar is full.

Unwinding the Loop

Automating starts with description, not code. Describe the loop tightly enough that something else could run it unsupervised, and most of the work is done before anyone opens an editor. The mechanics here are almost nothing: fetch text, generate text, put text somewhere. The decisions are the whole game, and this loop has two good ones: which ideas are strong enough to travel, and what your voice sounds like when it's compressed.

Here's the same loop written as a spec. Read the right-hand column and notice how much of it is judgment you've already made:

That table is the automation. Everything after this is choosing how much of it runs without you in the room. If you'd rather build the spec as a conversation than stare at an empty table, that's how BYOBot turns a task into a spec, one question at a time.

The Build: One Loop, Three Ways to Run It

One described loop becomes three builds. The only thing that changes between them is how much runs while you're asleep. Start at the top and move down when the top stops being enough.

The Prompt

The prompt build is zero setup: one saved prompt you paste into any AI chat tool along with your post. It won't schedule anything. It will hand you the week of drafts in about forty seconds, which on the day you publish is most of what you wanted.

You are repurposing one blog post into a week of channel drafts.
I will paste my voice samples first, then the post.

Step 1. Pull the 4 strongest standalone claims from the post.
A claim qualifies only if it makes sense with no article around it.
Prefer: a number, a contrarian line, a named example, a before/after.

Step 2. For each claim, write:
- LinkedIn: under 150 words, hook on line 1, blank line after it,
  no hashtags, end on a question.
- X: a 4-post thread, each under 260 characters, no thread numbering.
- Newsletter: 60 words, warmer, link at the end.

Rules:
- Match the rhythm of my voice samples, do not describe my tone.
- Never open with "In today's", "Ever wondered", or a rhetorical question.
- No emoji. No em dashes. American spelling.
- Reuse my exact phrasing from the post wherever it already works.

Return a table: Day | Channel | Draft | Which claim it came from.

VOICE SAMPLES:
[paste 5 posts you were happy with]

POST:
[paste the full article]

That runs the same in ChatGPT, Claude, or Gemini, because a prompt was never locked to one vendor. The voice samples are the part people skip and the part that decides whether the output is usable, so spend your effort there. When you notice you've pasted it for the eighth week running, that's the signal to let a script carry it, and the same spec is what lets you automate the repurposing pass that follows every post without you starting it.

The Script

Now the honest part, and this week it runs the opposite way to most builds we publish. Some loops need no AI at all, because comparing two numbers is arithmetic. This one needs a model and there's no way around it: turning an argument into a hook is generation, and no amount of clever string handling produces a sentence worth reading.

So put the model in exactly one seat, the writing, and give plain code everything else. Code fetches the post through the WordPress REST API or whatever your CMS exposes. Code splits it, holds the queue, stamps the dates, and pushes each draft out through the LinkedIn Posts API or the X API. Code logs what went where. The model writes, then gets out of the way.

// pseudo-shape of the script BYOBot generates for you
const post   = await cms.getPost(POST_ID);          // plain fetch
const voice  = await store.read(VOICE_SAMPLES);     // your own past posts

const drafts = await model.generate({               // the only AI call
  system: REPURPOSE_SPEC,                           // the prompt above
  input:  { post, voice, channels: CHANNELS }
});

for (const d of drafts) {
  if (d.text.length > LIMITS[d.channel]) continue;  // plain guardrail
  await queue.add({ ...d, runAt: nextSlot(d.channel) });
}

await notify(ME, summarize(drafts));                // one message, whole week

You don't start that from an empty file. BYOBot writes the full version: the file to create, the commands to run, the tokens to paste, and the channel limits wired to the ones you gave it. Run it once on a post you already repurposed by hand and compare the two sets side by side. That comparison is how you tune the prompt, and it's the same first step behind any build that has to automate the LinkedIn posting you do by hand.

The Schedule

The schedule is the smallest leap left. Stop launching the script and give it a trigger: your CMS fires a webhook when a post goes live, and the queue fills itself. If you'd rather keep it simple, a nightly run that checks for anything published since yesterday does the same job with less wiring. A cron job costs nothing, a GitHub Actions scheduled workflow costs nothing either, and if you want the posting side handled for you, Buffer takes a queue and pushes it out on the days you pick.

Here's how the three stack up, so you can pick your stopping point:

Steal This Build

Here's the whole loop as a spec you can hand to BYOBot or build yourself this afternoon. Copy it, swap the channel names for yours, drop in your own voice samples, and it's your build. If you want to get properly good at writing these from scratch, our guide on how to write a workflow spec goes deeper than we can here.

• Trigger: a post goes live, or a URL lands in the repurpose list.
• Extract: pull the three or four claims that stand alone without the article around them.
• Translate: rewrite each claim to the length, tone, and opening convention of each channel.
• Guard: drop anything over the character limit or containing a banned opener, before a human sees it.
• Report: write the week into a dated queue and send yourself one message with all of it.

Repurposing is the example, but look at the shape underneath: one source of truth, several audiences who each want it in a different wrapper, and a set of formatting rules you've memorized but never written down. Release notes into a changelog, a customer email, and a sales one-pager. A research doc into a deck and a summary. A support answer into a help article and a canned reply. Learn the pattern once and you'll spot it every week, which is the real return on learning to automate the marketing work your team repeats.

Frequently Asked Questions

• What is content repurposing? +
  Content repurposing is taking one piece you already made and reshaping it for the places your audience already reads. A blog post becomes a LinkedIn post, a short thread, a newsletter section, a set of slide captions. The research is done, the argument is settled, the examples are picked. What's left is a translation job: same idea, different length, different tone, different opening line. That translation is repetitive, rule-bound, and the single most automatable step in the whole publishing week, whether the destination is social or a newsletter you send on a schedule.
• Does repurposing need AI, or can a script do it? +
  This one genuinely needs a model, and it's worth naming the difference. Reconciling numbers is arithmetic and a plain script wins. Rewriting an argument into a LinkedIn hook is generation, and no amount of string slicing gets you there. So the model does the writing, and plain code does everything around it: fetching the post, splitting the sections, holding the queue, posting on schedule, logging what went out. Put the model only where language is being made, and the build stays fast and cheap.
• How do I stop the repurposed posts from sounding like a robot wrote them? +
  Feed the prompt your own past posts. Pick five or six you'd be happy to publish again, paste them in as examples, and tell the model to match their rhythm rather than describe their tone. Then add a banned list: the openers you never use, the emoji you never use, the words that give it away. A style guide written as rules gets you halfway. A style guide written as your own samples gets you the rest of the way, and if you want the theory behind why samples beat instructions, start with what prompt engineering really is.
• Should the posts publish automatically or wait for approval? +
  Start with approval and earn your way to automatic. For the first month, have the build write the drafts into a queue and send you one message with everything in it, so approving a week of content is a two-minute read. Once you've gone four weeks without meaningfully editing a draft, let the queue post itself and keep the notification. The rule of thumb: automate the writing before you automate the publishing, because a bad draft costs you a minute and a bad post costs you a morning.