Automating Your Content Pipeline: From Blog to Social in Seconds with Fabric

The most successful developers I know have one thing in common: they ship consistently. Not because they’re superhuman, but because they’ve automated the boring parts.

I used to spend 30 minutes after writing each blog post crafting different versions for LinkedIn, Twitter, Facebook, and other platforms. Thirty minutes of mind-numbing copy-paste-rewrite work that killed my momentum every single time.

Then I discovered Fabric and built something that changed everything: a single command that transforms any blog post into platform-optimized social content in under 10 seconds.

The Problem with Manual Social Distribution

Here’s what my old workflow looked like:

  1. Write blog post (fun part)
  2. Open LinkedIn, craft a professional version
  3. Open Twitter, squeeze it into 280 characters
  4. Open Facebook, make it more casual
  5. Repeat for other platforms
  6. Lose steam and forget to post half of them

Sound familiar? This manual approach has three major problems:

Context switching kills creativity. Just as I’d finish writing and feel proud of my work, I’d have to shift into “marketing mode” and butcher my prose into platform-specific chunks.

Inconsistent posting leads to inconsistent reach. Some platforms got love, others got ignored, and my content strategy looked like swiss cheese.

The friction was so high I’d often skip promotion entirely. Great content that nobody sees is just expensive therapy.

Enter Fabric: The AI Pattern Framework

Before diving into my solution, let me introduce you to Fabric—an open-source framework created by Daniel Miessler that’s revolutionizing how we integrate AI into daily workflows.

Fabric isn’t just another AI tool. It’s a pattern-based approach to AI automation that comes with over 200 pre-built, community-curated “patterns”—essentially high-quality, reusable AI prompts designed to solve specific problems.

What makes Fabric special:

  • Markdown-based patterns that are human-readable and easily customizable
  • CLI-first design perfect for automation and scripting
  • 200+ community patterns covering everything from content analysis to code generation
  • Multiple AI provider support (OpenAI, Claude, local models)
  • Cross-platform with shell completions and clipboard integration

Think of patterns as specialized AI tools. Instead of writing prompts from scratch every time, you use battle-tested patterns that the community has refined.

Building the Automation Pipeline

My solution uses a simple Makefile with two commands that handle everything:

# Rate the blog content quality
rate:
	@echo "Rating blog content..."
	@cat $(POST) | fabric --pattern rate_content

# Generate social media posts
social:
	@echo "Generating social media content..."
	@cat $(POST) | fabric --pattern create_social_linkedin > social/linkedin.md
	@cat $(POST) | fabric --pattern tweet > social/twitter.md
	@cat $(POST) | fabric --pattern create_facebook_post > social/facebook.md
	@cat $(POST) | fabric --pattern create_reddit_post > social/reddit.md
	@echo "✨ Social content generated for all platforms!"

But the real magic happens in those Fabric patterns. Some I use are from the community, others I’ve created myself.

The Rating System

Before generating social posts, I rate the blog content to ensure it’s worth promoting:

make rate POST=posts/latest-blog-post.md

This uses Fabric’s rate_content pattern, which analyzes:

  • Technical accuracy (1-10)
  • Clarity for target audience (1-10)
  • Actionable value (1-10)
  • Engagement potential (1-10)

The pattern provides specific feedback for improvement, catching weak posts before they hit social media.

Platform-Specific Generation

Each platform gets its own optimized Fabric pattern:

LinkedIn Professional Posts (create_social_linkedin):

# IDENTITY and PURPOSE
You are an allstar linkedin content creator and marketer. You take blog posts and turn them into engaging LinkedIn posts that bring recruiters to the candidate.

# STEPS
- Start with a strong hook that captures attention
- Tease 1-2 key insights from the blog post  
- Add a personal touch about why you wrote this
- Include a clear call to action with link
- Use professional tone with strategic emojis

Twitter Threads (tweet):

  • Breaks content into tweet-sized chunks
  • Creates engaging thread hooks
  • Optimizes for Twitter’s algorithm

Facebook Casual Posts (create_facebook_post):

  • Conversational, friend-to-friend tone
  • Story-driven approach
  • Community engagement focus

Reddit Community Posts (create_reddit_post):

  • Platform-appropriate tone and formatting
  • Value-first approach
  • Avoids promotional language

Custom Patterns I’ve Created

Beyond the community patterns, I’ve created some specialized ones:

Blog Quality Rater (my custom pattern):

fabric --pattern my_blog_rater --input blog-post.md

This pattern specifically looks for:

  • Technical depth vs accessibility balance
  • Clear actionable takeaways
  • Personal story integration
  • Industry relevance

Developer Social Generator (my custom pattern):

fabric --pattern dev_social_generator --input technical-post.md

Optimized for technical content, this pattern:

  • Translates jargon for broader audiences
  • Highlights practical code examples
  • Creates platform-specific technical summaries

GitHub Actions Integration

Here’s where it gets really powerful. I’ve wrapped this entire workflow in a GitHub Action that triggers whenever I push a new blog post. Provided below is a general pattern:

name: Generate Social Content
on:
  push:
    paths: ['posts/**/*.md']

jobs:
  social-content:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v4
    
    - name: Install Fabric
      env:
        FABRIC_VERSION: "v1.4.195"
      run: |
        curl -L https://github.com/danielmiessler/fabric/releases/$FABRIC_VERSION/download/fabric-linux-amd64 > fabric
        chmod +x fabric
        sudo mv fabric /usr/local/bin/
        
    - name: Setup Fabric
      run: fabric --setup
      env:
        OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
    
    - name: Get changed markdown files
      id: changed-files
      run: |
        CHANGED_MD=$(git diff --name-only HEAD~1 HEAD | grep "posts/.*\.md$" | head -1)
        echo "post_file=$CHANGED_MD" >> $GITHUB_OUTPUT
    
    - name: Rate blog content
      if: steps.changed-files.outputs.post_file
      run: make rate POST=${{ steps.changed-files.outputs.post_file }}
      
    - name: Generate social posts
      if: steps.changed-files.outputs.post_file
      run: make social POST=${{ steps.changed-files.outputs.post_file }}
    
    - name: Commit generated content
      run: |
        git config --local user.email "action@github.com"
        git config --local user.name "GitHub Action"
        git add social/
        git commit -m "Generated social content for latest post" || exit 0
        git push
        
    - name: Notify Slack
      uses: 8398a7/action-slack@v3
      with:
        status: success
        text: "New social content generated! Check the social/ directory."
      env:
        SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

Now every time I push a blog post to my repository, the system automatically:

  1. Rates the content quality using Fabric patterns
  2. Generates platform-specific social posts with community-tested patterns
  3. Commits the results back to the repo
  4. Sends me a Slack notification with the generated content

The Results

This Fabric-powered automation has transformed my content distribution:

Consistency: Every blog post gets promoted across all platforms without exception, using proven patterns refined by the community.

Quality: The AI-generated posts often perform better than my manual attempts because they’re optimized using patterns that hundreds of developers have tested and refined.

Speed: What used to take 30+ minutes now happens in under 10 seconds.

Continuous Improvement: As the Fabric community improves patterns, my content automatically gets better. When someone optimizes the tweet pattern for better engagement, I benefit immediately.

Community Learning: I contribute my custom patterns back to Fabric, and use patterns others have shared. It’s collective intelligence applied to content creation.

Implementation Tips

If you want to build something similar, here are the key lessons I learned:

Start with existing Fabric patterns. Don’t reinvent the wheel. The community has already solved most common content transformation problems. Install Fabric and explore the 200+ patterns available.

Customize gradually. Begin with patterns like summarize, extract_wisdom, and rate_content. Once you understand how they work, start tweaking them for your specific needs.

Build a pattern library. Create a ~/.config/fabric/patterns/ directory for your custom patterns. Follow Fabric’s markdown structure for consistency.

Test with real content. Run your patterns against actual blog posts to see how they perform. Fabric’s --stream flag is great for watching the AI work in real-time.

Automate incrementally. Start with manual commands (fabric --pattern summarize < blog-post.md), then build Makefile targets, then GitHub Actions.

Contribute back. If you create a useful pattern, consider contributing it to the Fabric project. The community benefits, and you get feedback to improve your patterns.

Beyond Social Media

This same pattern-based approach works for any repetitive content task:

  • Email newsletter summaries using create_newsletter_entry
  • Documentation generation with explain_docs
  • Code explanations via explain_code
  • Meeting summaries through summarize_meeting
  • Research synthesis with extract_insights

The key is identifying where you’re doing the same transformation work repeatedly, then either finding an existing Fabric pattern or creating a new one.

Sample Custom Patterns

Here’s one of my custom patterns for developer content:

# IDENTITY and PURPOSE
You are an expert at transforming technical blog posts into engaging social media content for developers. You understand both the technical depth and the social media landscape.

# STEPS
- Extract the core technical concept being explained
- Identify the practical problem this solves for developers
- Find the most "aha moment" insight from the post
- Craft a hook that makes developers stop scrolling
- Include specific technical details that demonstrate expertise
- End with a clear call to action

# OUTPUT INSTRUCTIONS
- Write in a conversational, developer-to-developer tone
- Include relevant emojis but don't overdo it
- Keep within platform limits (280 chars for Twitter, etc.)
- Always include a clear link back to the full post
- Focus on practical value over promotional language

You can save this as ~/.config/fabric/patterns/dev_social_hook/system.md and use it with:

fabric --pattern dev_social_hook < my-technical-post.md

The Bigger Picture

This isn’t really about social media automation. It’s about leveraging collective intelligence to remove friction from creative processes.

Fabric represents something bigger than individual AI tools—it’s a community-driven approach to AI integration. When you use a Fabric pattern, you’re benefiting from the combined experience of hundreds of developers who have refined that pattern through real-world use.

Every minute spent on repetitive tasks is a minute not spent thinking, building, or solving interesting problems. Good automation doesn’t replace human creativity—it amplifies it by removing the boring parts and leveraging community wisdom.

What repetitive tasks are stealing your creative energy? And more importantly, what would you create if those tasks disappeared and you had access to the collective intelligence of the developer community?

Fabric is open source and actively maintained by a vibrant community. Get started at danielmiessler/fabric.