Newsletter to Social: The Agent Pipeline for Solo Writers

The Sunday repurposing chore, automated.

In short:

• Your newsletter issue is already a week of social content. The writing is done. The missing step is extraction, and extraction is mechanical work.
• An agent reads the issue, drafts platform-native posts into your queue as drafts over MCP, and you approve them in batches.
• The whole loop: one issue in, queue loaded, about 15 minutes of review, tracked links driving readers back to the newsletter.

You publish a newsletter, and the best material you produced all week goes quiet after the send. Your social accounts stay silent because turning the issue into posts is a second job, and the second job is the one you skip when the week runs long. It does not have to be. I run an agent pipeline that reads each issue, drafts a week of platform-native posts, and leaves me a 15-minute review pass instead of a Sunday chore. Your newsletter already contains the week’s social content. Extraction is the only missing step, and that is a job for a machine.

Sunday repurposing is a tax on writers who already published

Repurposing is not a writing problem. The issue is written and edited by the time it ships. Rewriting it for four platforms is formatting work, and formatting work is what agents are for.

If you run a newsletter, you know the ritual. Open the issue, find the strongest paragraphs, trim one to a quote for X, rewrite another as a LinkedIn post, turn a third into an Instagram caption, repeat next week. Each platform eats thirty minutes, and none of it feels like writing. It feels like data entry on material you already wrote. That hour is the tax, and it compounds. Every subscriber you add makes the issue bigger, the rewrite longer, and the skip more tempting.

The tooling gap is why the chore survived. Scheduling apps handled the calendar years ago, but the drafting step always sat on the writer’s side, with no bridge between the finished issue and the post composer. That bridge is exactly what an agent closes: it does the reading and the rewriting, and a scheduling tool does the rest.

The pipeline: one issue in, a week of drafts out

The pipeline has three steps. The agent reads the issue, applies an extraction prompt, and writes the results into PostSider as drafts. Nothing goes live until you approve it.

The extraction prompt is my own framework, and it is the only piece of this setup that took real iteration. Its job is to read the issue once and decide what each platform should get. From a single issue it produces a small set of posts: two or three quotable lines with the sharpest phrasing kept intact, one argument worth a thread of three to five posts, and one visual note, which is a caption plus an image idea. Everything is written platform-native, meaning the version for X obeys its character limit and the version for LinkedIn reads like a LinkedIn post.

The prompt enforces three rules that keep the output usable. Quotes stay verbatim, never paraphrased. The agent takes facts and numbers only from the issue and never adds claims of its own. And the author’s voice carries through every variant, so the thread on X and the caption on Instagram both sound like the person who wrote the issue. That last rule is the one that separates extraction from generation: the agent is selecting and shaping what you already wrote, not inventing a new voice for your brand.

The agent does the extraction with the issue pasted into a chat, and it writes the results straight into PostSider over MCP. The connection is one config block in Claude Desktop, added through the Developer settings screen, which opens claude_desktop_config.json for you:

{
  "mcpServers": {
    "postsider": {
      "command": "npx",
      "args": ["-y", "@postsider/mcp"],
      "env": {
        "POSTSIDER_API_KEY": "your-api-key"
      }
    }
  }
}

That is the entire setup. The MCP server exposes 12 tools for posting, scheduling, and reviewing, and the agent discovers them itself at connect time, so you never maintain a tool list by hand. If you want the mechanics behind the tool discovery, the MCP walkthrough covers the protocol end to end.

Platform-native extraction beats link-blasting

Link-blasting posts the same “read my newsletter” line to every network and calls it a strategy. Extraction reads the issue once and gives each platform what that platform rewards: a quote for X, an argument for LinkedIn, a visual note for Instagram.

The reason link-blasting fails is that it asks the reader to do all the work. There is no hook and no payoff, so there is no reason to click. Extraction inverts that. The post itself carries one strong moment from the issue, and the link to the full argument is the reward, not the bait. This is also where per-platform caption variants pay off. The agent drafts a separate caption for each network instead of one text pasted everywhere, and PostSider keeps those variants attached to a single logical post, so you review one entry instead of four orphans.

For the formats I skip entirely and the ones that actually earn attention, I wrote a longer piece on repurposing content in 2026 that goes beyond the newsletter case.

The 15-minute review pass is the whole safety story

Every post the agent writes lands with draft status. Nothing publishes until you open the queue and approve it. That gate is the difference between an agent you trust and one you babysit.

I run PostSider’s own accounts on a queue like this, and the review pass is the part I never skip. Read the drafts top to bottom, cut anything that misses the issue’s voice, approve the rest in one batch. The Post Checker scans each caption for spelling and phrasing problems before you approve, which catches the errors an agent is blind to, and the caption rewrite fixes tone in place when a draft needs a lighter touch. Approving in batches is what keeps the pass at 15 minutes for a week of posts. Approve one by one and the overhead eats the saving.

If you are new to letting agents near your accounts, the posting-without-disaster guide walks through the failure modes, starting with the one that matters most: never let the agent skip the review.

Load the queue once and the week schedules itself

Approved drafts move into the posting queue, and the queue fills the next free slot on each channel. One load covers the week, across 30+ platforms, without you touching a calendar.

The scheduling is the part that quietly saves the most time. You are not picking times; the queue is. Each post takes the next free slot on its channel, so the week fills in evenly and your best material stops competing with your own posts. For every link back to the newsletter, the UTM tagging template stamps the destination with the platform and the issue number, so the analytics tell you which network actually converts readers. That data feeds back into the extraction prompt: the platform that earns opens gets the sharpest quote next week.

This is the point where I should say what I use. PostSider is the tool I built for exactly this loop, and the pipeline above is how its own accounts run. Create a free account, connect your channels, and the setup from this post is one config block away.

The post should tease the newsletter, not summarize it

A social post is a storefront. Its job is to make one strong point and send the reader to the full argument in the issue, with a link that tells you where they came from.

Teaser copy follows a shape I stick to. Open with the sharpest line from the issue, the one that made you want to write it. Make the point the post can carry alone. Close with the pull: the full argument or the worked example lands in this week’s issue, and the link goes there. If the post gives away the entire argument, there is no reason to open the newsletter. If it gives away nothing, there is no reason to click. The teaser sits between the two: one complete idea, and one reason to click through.

The Sunday chore is gone. The issue is written by Tuesday, the agent extracts by Wednesday, and Thursday’s review takes 15 minutes. That is the whole system, and it costs one config block and one extraction prompt.

Lukasz Blania is the founder of PostSider. He writes about solo-founder content operations and runs PostSider’s own social accounts through pipelines like the one above.