Auto-Repurpose One Blog Post into 10 Social Posts with n8n + Claude

You published a blog post. It took you 4 hours to research, write, edit, and format. You share it once on Twitter. Maybe once on LinkedIn. It gets 200 views. Then it's gone.

Meanwhile, some creator with half your expertise is everywhere — LinkedIn, Twitter, Instagram, YouTube, newsletters — posting every day, building an audience 10x faster than you.

The difference isn't talent. It's not even time. It's systems.

I manage content across platforms for 280K+ followers. I don't write 10 pieces of content a day. I write one — and a workflow turns it into ten. This is the exact n8n + Claude automation I use to do it, and you can set it up in 15 minutes.

Why Content Repurposing Is the Only Scalable Content Strategy

Let's do the math. If you're posting on 4 platforms and each platform needs 3-5 posts per week to stay relevant in the algorithm, that's 12-20 pieces of content. Every. Single. Week.

Nobody has time for that. And if you try to write each piece from scratch, three things happen:

1. Quality drops. You start rushing. Posts become generic. Your audience notices.
2. Burnout hits. Content creation becomes a chore instead of a growth lever.
3. Inconsistency creeps in. You miss days, then weeks, then months. Algorithm stops showing you.

Repurposing fixes all three problems. You put your best thinking into one long-form piece — a blog post, a newsletter essay, a podcast — and then you systematically extract different angles, formats, and hooks for every platform.

The key insight: each platform rewards different formats, but the underlying ideas are the same. LinkedIn rewards storytelling and contrarian takes. Twitter rewards punchy threads and tactical breakdowns. Instagram rewards visual frameworks and step-by-step slides. YouTube Shorts rewards fast hooks and pattern interrupts.

Same ideas. Different packaging. That's what this workflow automates.

The Workflow Architecture

Here's what the full pipeline looks like:

┌─────────────────┐
│  Webhook/RSS     │  ← Your CMS publishes a new post
│  Trigger         │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  HTTP Request    │  ← Fetch the full blog post content
│  (Fetch Post)    │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Code Node       │  ← Strip HTML, extract clean text
│  (Extract Text)  │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Claude AI       │  ← Extract key points, quotes, stats,
│  (Analyze Post)  │     thesis, hooks, contrarian angles
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Code Node       │  ← Parse Claude's JSON response
│  (Parse Output)  │
└────────┬────────┘
         │
    ┌────┼────┬────────┬────────┬──────────┐
    ▼    ▼    ▼        ▼        ▼          ▼
┌──────┐┌──────┐┌──────────┐┌────────┐┌──────────┐
│Claude││Claude││Claude    ││Claude  ││Claude    │
│Linked││Twitt-││Instagram ││YouTube ││Newslett- │
│In x3 ││er x3 ││Carousel  ││Short   ││er Intro  │
│      ││      ││x2        ││Script  ││          │
└──┬───┘└──┬───┘└────┬─────┘└───┬────┘└────┬─────┘
   │       │         │          │           │
   └───────┴─────────┴──────┬───┴───────────┘
                            │
                            ▼
                   ┌─────────────────┐
                   │  Code Node       │  ← Merge + format all outputs
                   │  (Merge All)     │
                   └────────┬────────┘
                            │
                            ▼
                   ┌─────────────────┐
                   │  Google Sheets   │  ← Write to Content Calendar
                   │  (Output)        │
                   └────────┬────────┘
                            │
                            ▼
                   ┌─────────────────┐
                   │  Slack Notify    │  ← "10 posts ready for review"
                   └─────────────────┘

13 nodes. 5 parallel Claude calls. One trigger. The whole thing runs in about 30-45 seconds.

Node-by-Node Breakdown

Node 1: Webhook Trigger

The workflow starts when your CMS publishes a new blog post. You have two options:

• Webhook: Your CMS (WordPress, Ghost, Webflow, custom Next.js) sends a POST request with the blog URL, title, and topic when you hit publish.
• RSS Feed: n8n polls your blog's RSS feed every hour and triggers when a new entry appears.

I use the webhook approach because it's instant — no polling delay. Here's the payload format:

{
  "url": "https://yourblog.com/posts/my-new-article",
  "title": "How I Built a $10K/mo SaaS in 6 Weeks with AI",
  "author": "Knox",
  "topic": "AI development"
}

In your CMS, add a webhook action on the "publish" event. Point it at your n8n webhook URL. Done.

Node 2: HTTP Request — Fetch the Blog Post

The webhook only sends the URL. We need the actual content. The HTTP Request node fetches the full page HTML:

URL: {{ $json.body.url }}
Method: GET
Response Format: Text (full HTML)

Why not just send the content in the webhook? Because most CMS platforms don't include full HTML in webhook payloads, and fetching the published page ensures you get the final rendered version with all formatting intact.

Node 3: Code Node — Extract Clean Text

The raw HTML includes navigation, footers, sidebars, scripts — everything you don't want Claude processing. This Code node strips it down to just the article text:

// Extract main content from HTML
const html = $input.first().json.data;

// Strip non-content elements
let text = html
  .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
  .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
  .replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, '')
  .replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, '')
  .replace(/<header[^>]*>[\s\S]*?<\/header>/gi, '')
  .replace(/<[^>]+>/g, '\n')
  .replace(/\n{3,}/g, '\n\n')
  .trim();

// Get metadata from webhook
const title = $('Webhook - New Blog Post').first().json.body.title || 'Untitled';
const author = $('Webhook - New Blog Post').first().json.body.author || 'Knox';

// Truncate to stay within Claude's sweet spot
if (text.length > 6000) {
  text = text.substring(0, 6000) + '...';
}

return [{
  json: { title, author, content: text, charCount: text.length }
}];

The 6,000 character truncation is intentional. You want Claude to have enough context to understand the full argument, but sending a 15,000-word post doesn't improve output quality — it just burns tokens and slows things down.

Node 4: Claude AI — Extract Key Points

This is the "brain" node. Instead of asking Claude to write social posts directly from raw text (which produces generic results), we first extract structured intelligence that all downstream nodes can use.

The extraction prompt:

You are a content strategist extracting key information from a blog post.

Blog post title: {{ $json.title }}
Blog post content:
---
{{ $json.content }}
---

Extract the following and return ONLY valid JSON:
{
  "main_thesis": "The single core argument in one sentence",
  "key_points": ["point 1", "point 2", "point 3", "point 4", "point 5"],
  "quotable_lines": ["quote 1", "quote 2", "quote 3"],
  "statistics": ["any numbers or data points mentioned"],
  "target_audience": "who this post is for",
  "emotional_hook": "the pain point or desire this addresses",
  "contrarian_take": "what makes this different from mainstream advice"
}

Settings: temperature: 0.3 (we want precision here, not creativity), max_tokens: 1500.

This structured extraction is the secret sauce. Every platform-specific prompt downstream receives these distilled talking points rather than raw article text. The result: more focused, platform-native content.

Node 5: Code Node — Parse the Extraction

Claude returns a JSON string. This node parses it and passes it forward with the original metadata:

const response = $input.first().json.response;
let extracted;
try {
  let clean = response.replace(/```json\n?/g, '').replace(/```\n?/g, '').trim();
  extracted = JSON.parse(clean);
} catch (e) {
  // Fallback if Claude wraps in markdown
  extracted = {
    main_thesis: response.substring(0, 200),
    key_points: [],
    quotable_lines: [],
    statistics: [],
    target_audience: 'builders and creators',
    emotional_hook: '',
    contrarian_take: ''
  };
}

const original = $('Code - Extract Content').first().json;
return [{ json: { ...original, extracted } }];

The try/catch is important. Claude sometimes wraps JSON in markdown code blocks. The regex strips those. The fallback ensures the workflow doesn't crash if extraction fails — it just produces less precise downstream content.

Nodes 6-10: Five Parallel Claude Calls

Here's where the multiplication happens. After the extraction is parsed, n8n fans out to five parallel Claude nodes, each with a platform-specific prompt. They all run simultaneously — no waiting.

Let me walk through each prompt and why it's structured this way.

The Claude Prompts — Platform by Platform

LinkedIn Prompts (3 posts, 3 angles)

You are a LinkedIn ghostwriter for a tech thought leader with 280K+ followers.

Original blog post title: {{ $json.title }}
Main thesis: {{ $json.extracted.main_thesis }}
Key points: {{ $json.extracted.key_points.join('; ') }}
Quotable lines: {{ $json.extracted.quotable_lines.join('; ') }}
Target audience: {{ $json.extracted.target_audience }}
Emotional hook: {{ $json.extracted.emotional_hook }}
Contrarian take: {{ $json.extracted.contrarian_take }}

Write 3 LinkedIn posts (DIFFERENT angles). Each post 150-250 words.

Format rules:
- Start with a bold hook line (pattern interrupt)
- Use short paragraphs (1-2 sentences each)
- Add line breaks between paragraphs for readability
- End with a question or CTA to drive comments
- No hashtags in the body — add 3-5 hashtags at the very end
- Sound human, not corporate. Conversational but authoritative.

Post 1 angle: CONTRARIAN — challenge a common belief
Post 2 angle: STORY — personal experience or case study
Post 3 angle: TACTICAL — specific how-to takeaway

Return ONLY valid JSON:
{
  "linkedin_post_1": { "hook": "...", "body": "...", "hashtags": ["#tag1"] },
  "linkedin_post_2": { "hook": "...", "body": "...", "hashtags": ["#tag1"] },
  "linkedin_post_3": { "hook": "...", "body": "...", "hashtags": ["#tag1"] }
}

Why three angles? Because you can space them out over a week and each one feels like original content. Monday: contrarian take. Wednesday: personal story. Friday: tactical breakdown. Same source material, three completely different engagement patterns.

Why "no hashtags in body"? LinkedIn's algorithm actually penalizes posts with hashtags mid-text. Put them at the end, after a line break.

Twitter/X Prompts (3 threads)

You are a Twitter/X ghostwriter for a tech creator with a sharp, punchy voice.

Original blog post title: {{ $json.title }}
Main thesis: {{ $json.extracted.main_thesis }}
Key points: {{ $json.extracted.key_points.join('; ') }}
Quotable lines: {{ $json.extracted.quotable_lines.join('; ') }}
Contrarian take: {{ $json.extracted.contrarian_take }}

Write 3 Twitter/X threads. Each thread has 5-7 tweets.

Format rules:
- Tweet 1: Hook. Must stop the scroll. Max 200 characters.
- Tweets 2-6: One key idea per tweet. Max 280 characters each.
- Last tweet: CTA (link to full post, follow, etc.)
- Use thread numbering: 1/ 2/ 3/
- No emojis in the first tweet. Use sparingly elsewhere.
- Write like you talk, not like a press release.

Thread 1: HOT TAKE — bold controversial opinion
Thread 2: BREAKDOWN — "Here's how X works (step by step)"
Thread 3: LESSONS — "N things I learned from..."

Return ONLY valid JSON:
{
  "thread_1": { "angle": "hot take", "tweets": ["1/ text", "2/ text"] },
  "thread_2": { "angle": "breakdown", "tweets": ["1/ text", "2/ text"] },
  "thread_3": { "angle": "lessons", "tweets": ["1/ text", "2/ text"] }
}

Why 5-7 tweets per thread? Data from my own account: threads under 4 tweets get 60% less engagement than 5-7 tweet threads. Over 8 tweets and completion rate drops off a cliff. The sweet spot is 5-7.

Why "no emojis in tweet 1"? The first tweet shows up in the timeline without thread context. Emojis make it look like marketing, and people scroll past marketing. Raw text with a bold claim gets more pauses.

Instagram Carousel Prompts (2 carousels)

You are an Instagram content strategist creating carousel posts.

Original blog post title: {{ $json.title }}
Main thesis: {{ $json.extracted.main_thesis }}
Key points: {{ $json.extracted.key_points.join('; ') }}
Statistics: {{ $json.extracted.statistics.join('; ') }}
Emotional hook: {{ $json.extracted.emotional_hook }}

Write 2 Instagram carousel scripts. Each carousel has 8-10 slides.

Format rules per slide:
- HEADLINE: Large text (5-8 words max)
- BODY: Supporting text (15-25 words max)
- Slide 1: Hook — must stop the scroll
- Slides 2-8: One idea per slide, progressive reveal
- Second-to-last slide: Summary/recap
- Last slide: CTA (save, share, follow, link in bio)
- Include caption text with 5 relevant hashtags

Carousel 1: EDUCATIONAL — teach something specific
Carousel 2: MYTH-BUSTING — "Stop doing X, do Y instead"

Return ONLY valid JSON:
{
  "carousel_1": {
    "angle": "educational",
    "slides": [{ "headline": "...", "body": "..." }],
    "caption": "...",
    "hashtags": ["#tag1"]
  },
  "carousel_2": {
    "angle": "myth-busting",
    "slides": [{ "headline": "...", "body": "..." }],
    "caption": "...",
    "hashtags": ["#tag1"]
  }
}

Why headline + body format? Because carousel slides are visual. When you hand this off to a designer (or use Canva templates), you need clear hierarchy: big text on top, small text below. The AI output maps directly to design templates.

Why 8-10 slides? Instagram's algorithm rewards saves and shares. Longer carousels get more saves because people bookmark them as reference material. 8-10 is the sweet spot — enough depth to be valuable, not so long that people give up swiping.

YouTube Shorts Script

You are a short-form video scriptwriter.

Original blog post title: {{ $json.title }}
Main thesis: {{ $json.extracted.main_thesis }}
Key points: {{ $json.extracted.key_points.join('; ') }}
Contrarian take: {{ $json.extracted.contrarian_take }}

Write 1 YouTube Shorts script (max 60 seconds spoken).

Structure:
- HOOK (0-3 sec): Pattern interrupt. Polarizing or surprising.
- SETUP (3-15 sec): Frame the problem.
- BODY (15-45 sec): 2-3 punchy points. Use "Here's the thing" transitions.
- CTA (45-60 sec): Follow / Link in bio / Comment if you agree
- Include [visual cues] in brackets for B-roll
- ~150 words total (150 wpm speaking pace)

Return ONLY valid JSON:
{
  "youtube_short": {
    "title": "...",
    "hook": "opening line",
    "script": "full script with [visual cues]",
    "cta": "closing call to action",
    "estimated_duration": "55 seconds",
    "hashtags": ["#shorts", "#tag1"]
  }
}

Why include [visual cues]? Because a script without shot direction is useless. When you sit down to record, you need to know exactly what to show on screen at each moment. The brackets tell you: "Now show the n8n canvas" or "Now show the Google Sheet."

Newsletter Intro

You are writing a newsletter intro for a tech creator's weekly email.

Original blog post title: {{ $json.title }}
Main thesis: {{ $json.extracted.main_thesis }}
Key points: {{ $json.extracted.key_points.join('; ') }}
Emotional hook: {{ $json.extracted.emotional_hook }}

Write 1 newsletter intro (100-150 words):
- Open with a personal/relatable observation
- Tease the blog post content
- Create curiosity to click through
- End with CTA: "Read the full breakdown here"
- Tone: writing to a friend who's also a builder
- Subject line: 6-10 words, curiosity or benefit driven

Return ONLY valid JSON:
{
  "newsletter": {
    "subject_line": "...",
    "preview_text": "...",
    "intro_paragraph": "...",
    "cta_text": "Read the full breakdown",
    "cta_url": "[BLOG_POST_URL]"
  }
}

Platform-Specific Formatting Rules

Each platform has its own quirks. Here's what the workflow accounts for:

Platform	Max Length	Best Practices	Hashtag Strategy
LinkedIn	3,000 chars	Hook in first 2 lines (before "see more"). Short paragraphs. End with question.	3-5 hashtags at the end. Mix broad (#AI) with niche (#vibecoding).
Twitter/X	280 chars/tweet	Thread format: 1/ 2/ 3/. First tweet is standalone hook. Last tweet is CTA.	0-2 hashtags max per tweet. Twitter penalizes hashtag stuffing.
Instagram	2,200 chars caption	Carousel: 8-10 slides. Big headlines, short supporting text. Visual hierarchy.	5-10 hashtags in caption. Mix sizes: 2 big, 3 medium, 5 niche.
YouTube Shorts	60 sec / ~150 words	Hook in first 3 seconds or die. Fast cuts. Direct to camera + B-roll mix.	#shorts mandatory. 2-3 topic hashtags in description.
Newsletter	No hard limit	Subject line under 50 chars. Preview text under 90 chars. Intro teases, doesn't reveal.	N/A

Node 11: The Merge Node — Combining Everything

After all five Claude calls complete, a Code node collects every output and formats it into rows for Google Sheets. This is the most important piece of JavaScript in the workflow:

// Collect all Claude outputs
const linkedin = safeParse($('Claude - LinkedIn Posts').first().json);
const twitter = safeParse($('Claude - Twitter Threads').first().json);
const instagram = safeParse($('Claude - Instagram Carousels').first().json);
const youtube = safeParse($('Claude - YouTube Short Script').first().json);
const newsletter = safeParse($('Claude - Newsletter Intro').first().json);

const today = new Date().toISOString().split('T')[0];
const rows = [];

// LinkedIn — 3 rows
['linkedin_post_1', 'linkedin_post_2', 'linkedin_post_3'].forEach((key, i) => {
  const angles = ['Contrarian', 'Story', 'Tactical'];
  if (linkedin[key]) {
    rows.push({
      platform: 'LinkedIn',
      format: `Post (${angles[i]})`,
      content: linkedin[key].body,
      hashtags: (linkedin[key].hashtags || []).join(' '),
      scheduled_date: today,
      status: 'Draft',
      source_post: original.title
    });
  }
});

// Twitter — 3 rows (joined tweets)
['thread_1', 'thread_2', 'thread_3'].forEach(key => {
  if (twitter[key]) {
    rows.push({
      platform: 'Twitter/X',
      format: `Thread (${twitter[key].angle})`,
      content: (twitter[key].tweets || []).join('\n\n'),
      hashtags: '',
      scheduled_date: today,
      status: 'Draft',
      source_post: original.title
    });
  }
});

// Instagram — 2 rows (slides formatted)
['carousel_1', 'carousel_2'].forEach(key => {
  if (instagram[key]) {
    const slides = instagram[key].slides
      .map((s, i) => `Slide ${i+1}: ${s.headline} — ${s.body}`)
      .join('\n');
    rows.push({
      platform: 'Instagram',
      format: `Carousel (${instagram[key].angle})`,
      content: slides + '\n\nCaption: ' + instagram[key].caption,
      hashtags: (instagram[key].hashtags || []).join(' '),
      scheduled_date: today,
      status: 'Draft',
      source_post: original.title
    });
  }
});

// YouTube Short — 1 row
if (youtube.youtube_short) {
  rows.push({
    platform: 'YouTube Shorts',
    format: 'Short Script',
    content: youtube.youtube_short.script,
    hashtags: (youtube.youtube_short.hashtags || []).join(' '),
    scheduled_date: today,
    status: 'Draft',
    source_post: original.title
  });
}

// Newsletter — 1 row
if (newsletter.newsletter) {
  rows.push({
    platform: 'Newsletter',
    format: 'Email Intro',
    content: 'Subject: ' + newsletter.newsletter.subject_line +
             '\n\n' + newsletter.newsletter.intro_paragraph,
    hashtags: '',
    scheduled_date: today,
    status: 'Draft',
    source_post: original.title
  });
}

return rows.map(row => ({ json: row }));

Each row becomes one entry in your content calendar. 10 rows total — one for each piece of content.

The Google Sheets Output Template

Create a Google Sheet called "Content Calendar" with these columns:

Platform	Format	Content	Hashtags	Scheduled Date	Status	Source Post
LinkedIn	Post (Contrarian)	[generated text]	#AI #vibecoding	2025-03-15	Draft	How I Built a $10K SaaS
LinkedIn	Post (Story)	[generated text]	#buildinpublic	2025-03-15	Draft	How I Built a $10K SaaS
LinkedIn	Post (Tactical)	[generated text]	#solofounder	2025-03-15	Draft	How I Built a $10K SaaS
Twitter/X	Thread (Hot Take)	[generated thread]		2025-03-15	Draft	How I Built a $10K SaaS
Twitter/X	Thread (Breakdown)	[generated thread]		2025-03-15	Draft	How I Built a $10K SaaS
Twitter/X	Thread (Lessons)	[generated thread]		2025-03-15	Draft	How I Built a $10K SaaS
Instagram	Carousel (Educational)	[slide-by-slide script]	#contentcreation	2025-03-15	Draft	How I Built a $10K SaaS
Instagram	Carousel (Myth-Busting)	[slide-by-slide script]	#mythbusted	2025-03-15	Draft	How I Built a $10K SaaS
YouTube Shorts	Short Script	[60-sec script]	#shorts	2025-03-15	Draft	How I Built a $10K SaaS
Newsletter	Email Intro	[subject + intro]		2025-03-15	Draft	How I Built a $10K SaaS

The "Status" column is your workflow tracker. Change it from "Draft" to "Reviewed" to "Scheduled" to "Published" as you go through each piece. You can also add conditional formatting in Google Sheets: green for published, yellow for scheduled, red for draft.

Setup Instructions — 15 Minutes

Here's the complete setup, step by step:

1. Download the template. Get the .json file from the download section below.
2. Import into n8n. Open n8n → Workflows → Import from File → select the .json.
3. Set up Anthropic credentials. Go to Settings → Credentials → Add → Anthropic API. Paste your API key from console.anthropic.com.
4. Set up Google Sheets credentials. Settings → Credentials → Add → Google Sheets OAuth2. Follow the OAuth flow.
5. Create your Google Sheet. Make a new sheet called "Content Calendar" with columns: Platform, Format, Content, Hashtags, Scheduled Date, Status, Source Post.
6. Update the Sheet ID. In the "Google Sheets - Content Calendar" node, replace YOUR_GOOGLE_SHEET_ID with your actual sheet ID (the long string in the Google Sheets URL).
7. (Optional) Set up Slack. If you want notifications, add Slack credentials. Otherwise, delete or disable the Slack node.
8. Activate the workflow. Toggle the workflow to Active. Your webhook URL is now live.
9. Connect your CMS. Add a webhook to your publishing flow that POSTs to your n8n webhook URL with { "url": "...", "title": "...", "author": "..." }.
10. Test it. Publish a blog post (or send a manual POST request with curl) and watch 10 content pieces appear in your sheet.

Quick test with curl:

curl -X POST https://your-n8n-instance.com/webhook/new-blog-post \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://yourblog.com/posts/test-post",
    "title": "Test Post: Why AI Changes Everything",
    "author": "Knox",
    "topic": "AI"
  }'

Real Example: Full Output

Let me show you what this actually produces. I ran the workflow on a blog post titled "Why Most Vibe Coders Never Ship — and the 3 Mindset Shifts That Fix It". Here's a sample of the output.

LinkedIn Post (Contrarian angle)

Vibe coding doesn't have a skill problem. It has a shipping problem.

I've watched hundreds of builders in my community. The pattern is always the same:

They prototype in 2 hours. Then spend 3 weeks "polishing." Then never launch.

The uncomfortable truth? Your MVP doesn't need to be good. It needs to exist.

The best products I've seen launched looked terrible on day one. But they were live. Collecting feedback. Iterating with real data instead of imaginary scenarios.

Three shifts that changed everything for our community:

1. Deploy on day one, not day thirty.
2. Replace "what if it breaks" with "what if nobody cares."
3. Set a 48-hour launch deadline for every project.

The market doesn't reward perfect code. It rewards people who show up.

What's your biggest shipping blocker right now?

#vibecoding #buildinpublic #solofounder #AI #shipping

Twitter/X Thread (Breakdown angle)

1/ Most vibe coders are stuck in an infinite build loop. Here's the exact framework to break out — step by step.

2/ Step 1: Set a 48-hour deadline. Not for perfection. For deployment. Push something live before your inner critic catches up.

3/ Step 2: Replace "what if it breaks" with "what if nobody cares." The second question is scarier — and more useful.

4/ Step 3: Deploy to production on day one. Not localhost. Not staging. Production. Real URL. Real users can find it.

5/ Step 4: Ship the feature that scares you. The one you keep "saving for later." That's the one the market actually wants.

6/ Step 5: Show your work. Post the ugly v1. People respect builders more than perfectionists.

7/ Full breakdown on why this works (and the data behind it): [link] — follow for more shipping frameworks.

Instagram Carousel (Educational)

Slide 1: Why 90% of Vibe Coders Never Ship — And you might be one of them.

Slide 2: The Build Loop Trap — You prototype fast, then polish forever. Sound familiar?

Slide 3: Shift #1: Deploy Day One — Push to production before your inner critic wakes up.

Slide 4: Shift #2: Fear the Right Thing — Not "what if it breaks." Ask: "what if nobody cares?"

Slide 5: Shift #3: 48-Hour Deadline — Set a hard launch date. No exceptions. No extensions.

Slide 6: The Data — Builders who ship in 48 hours are 3x more likely to reach 100 users.

Slide 7: What Good v1s Look Like — Ugly. Incomplete. Alive. Getting real feedback.

Slide 8: Your Action Item — Pick one project. Set a 48-hour timer. Ship it. Tag me.

Slide 9: Save This Post — Follow @RoK11hn for more shipping frameworks. Link in bio.

YouTube Short Script

[HOOK — 0:00] "90% of vibe coders will never ship a single product. And it's not because they can't code."

[SETUP — 0:03] [show screen recording of half-finished projects] "I've mentored hundreds of AI builders. The pattern is always the same. They build a prototype in 2 hours — that part's easy now. Then they spend three weeks in the polish trap."

[BODY — 0:15] [cut to direct camera] "Here's the thing nobody tells you. Your v1 is supposed to be ugly. The goal isn't a perfect product. The goal is a live product. Deploy on day one. Not day thirty." [show deployment dashboard] "Replace 'what if it breaks' with 'what if nobody cares' — that's the real question. And set a 48-hour deadline for every project. Not a suggestion. A hard deadline."

[CTA — 0:50] [direct to camera] "Follow for more frameworks like this. I share the exact systems that helped our community ship over 200 products. Link in bio."

Newsletter Intro

Subject: You're building. But are you shipping?

Preview: The 3 mindset shifts that turned our community into a shipping machine.

Hey — Quick question. When's the last time you actually deployed something? Not prototyped. Not "almost done." Actually pushed to production where real humans could use it.

I asked this in our community last week and the silence was deafening. Turns out, most builders are stuck in what I call the infinite polish loop — and it has nothing to do with skill.

I wrote a full breakdown of the three mindset shifts that changed everything for us. We went from a community that builds cool demos to one that ships real products. The difference was smaller than you'd think.

Read the full breakdown here

That's 10 pieces of content from one blog post. The whole generation took 38 seconds.

Optional: Auto-Scheduling with Buffer or Typefully

The base workflow outputs everything to Google Sheets for manual review. But if you want to go full auto-pilot, you can add API nodes at the end:

• Buffer API: Schedule LinkedIn and Twitter posts directly. Buffer accepts text + scheduled time via their /updates/create endpoint.
• Typefully API: Even better for Twitter threads. Typefully's API lets you create drafts with thread formatting preserved.
• Later API: For Instagram carousel scheduling (you'll still need to create the visual slides separately, but the copy is ready).

I recommend keeping the Google Sheets step and reviewing content before auto-posting. AI-generated content is a starting point, not a finished product. A quick human edit — adjusting tone, adding a personal anecdote, fixing an awkward phrase — takes 2 minutes per piece and makes the difference between "clearly AI" and "clearly human."

Cost Breakdown

Let's talk money. Running this workflow once (one blog post → 10 outputs) costs approximately:

• Claude API: 6 API calls × ~2,000 tokens each = ~12,000 tokens. At Claude Sonnet pricing, that's roughly $0.04-0.08 per run.
• n8n: Self-hosted is free. n8n Cloud starts at $20/month for 2,500 executions.
• Google Sheets: Free.

If you publish 4 blog posts per month, you're generating 40 pieces of social content for under $0.32 in API costs. That's less than a cup of coffee for a month of content.

Wrapping Up

Content repurposing isn't lazy. It's leveraged. You put deep thinking into one piece and let automation handle the reformatting. Your audience on LinkedIn isn't the same as your audience on Twitter. They'll never see the overlap. They'll just see you showing up consistently with valuable content.

Download the template below, set it up in 15 minutes, and turn every blog post into a week's worth of content across every platform.

Stop creating more. Start distributing better.