Why I Built It (The Real Problem)
A blog post took me 4-6 hours: keyword research, outlining, writing, editing, fact-checking. I was publishing one post every two weeks. I wanted to write more frequently but didn't have the hours.
The obvious solution was "use AI." But not in the "paste into ChatGPT" way. I wanted to build a system where users submit a keyword, and the system generates a draft good enough to edit and publish.
Why build instead of buy? Because every "AI blog post generator" SaaS tool I tested was expensive ($99-299/month), produced mediocre output, and couldn't be customized. Building on Make.com meant I could own the entire process.
The Blog Post Generator launched about two years ago. It's now one of my seven live projects. People use it, it works, and I've learned a lot from maintaining it.
How It Works: The 10,000-Foot View
User flow:
- User visits a form and enters a target keyword (e.g., "Make.com automation for content creation").
- Optionally, they add notes or angles they want included.
- Form submits via webhook to Make.com.
- Make.com triggers two Claude API calls in sequence.
- First call: Generate an SEO-optimized outline.
- Second call: Write the full post based on that outline.
- Make.com formats the output as markdown and emails it to the user.
- User receives a draft ready for light editing.
Total time: 60-90 seconds from submission to email.
Total cost: ~$0.10 in API calls.
Stage 1: Keyword to Outline (The Two-Call Strategy)
The two-call approach is the core insight. Instead of asking Claude to write a blog post in one pass, I ask it to generate an outline first, then write the post based on that outline.
Why two calls? Because outlines are constraint-driven. Claude is better at understanding that an outline needs to be structured for SEO (H2s as main points, semantic keyword clustering, etc.). Once the outline exists, the second call just needs to follow it.
First Claude call prompt (summarized):
- Target keyword: [user input]
- Context: SEO blog post for Make.com users
- Generate a 6-8 H2 outline where each H2 is a unique angle on the keyword
- Include an estimated word count per section
- Include semantically related keywords to target
Claude returns an outline like:
- H2: Introduction to Make.com Automation
- H2: Why Content Creation is a Bottleneck
- H2: Setting Up Your First Workflow (keywords: webhook, automation, form)
- ...etc.
This outline is structured. It's already optimized for SEO because the prompt told it to be. Most AI tools don't do this pre-structuring step.
Stage 2: Outline to Full Post (The Writing Layer)
Second Claude call prompt (summarized):
- Here's an outline: [insert outline from call 1]
- Write the full blog post following this outline
- Voice: [my voice guide—conversational, Chicago-friendly, technical but accessible]
- Include 2-3 real examples per section
- Include a stat callout (formatted as JSON) mid-post
- Each section should be 300-400 words
Claude writes the full post in about 45 seconds. It follows the outline closely, which means the structure is already solid. My editing job is lighter—fixing voice drift, fact-checking, tightening.
By the second call, Claude is just filling in details. It's constrained by the outline, so it doesn't wander. Output quality is significantly better than if I just asked "write a blog post about this topic."
The SEO Optimization Layer
After both calls complete, Make.com handles formatting and adds SEO metadata.
The workflow generates:
- Meta description: 155 characters, includes the keyword naturally.
- H2 structure: Markdown formatting with proper heading hierarchy.
- Internal links suggestions: Based on the content, Make.com scans my knowledge base and suggests 2-3 internal links.
- Reading time estimate: Based on word count and complexity.
- Keyword density check: A simple loop counts target keyword mentions (aiming for 1-2% density).
This isn't sophisticated ML-powered SEO. It's template-based rules. But it ensures every post ships with basic SEO hygiene instead of relying on me to remember it.
Delivery and Formatting
After the content is generated, Make.com assembles the output:
- Markdown formatted with proper headings.
- Includes front matter: title, meta description, keywords, reading time.
- Formatted as an email attachment (markdown file) or embedded in the email body.
- User receives it ready to drop into their CMS.
The whole process is wrapped in error handling. If either Claude call fails (rare), the user gets an error message and a retry link, not a broken post.
Results: What Actually Happens in Practice
The generator cuts my content research and drafting time by about 60-70%, but I still spend 30-45 minutes editing each post.
What works well: The outline and structure are almost always usable. The writing is grammatically correct. The SEO basics are there.
What needs work: Voice consistency drifts mid-post. Some sections feel generic. The tool struggles with truly original insights (because it doesn't have my lived experience). Fact-checking is entirely manual.
Real numbers: Pre-generator, a post took 4-5 hours. Post-generator, it takes 2-2.5 hours (outline + first draft: 1 hour, editing + fact-check: 1-1.5 hours). That's a 50% time savings.
The generator produces work that looks and reads like human-written content, but readers who know my voice can sometimes tell it's AI-assisted. That's not a deal-breaker for me—it's transparent that the AI helped—but it's a real limitation.
Build Your Own: Key Decisions
If you're thinking about building something similar, here are the key decisions:
One-call vs. two-call: Two-call is more expensive ($0.10 vs. $0.05 per post) but produces better output. Spend the extra penny.
Which model: Claude for quality, GPT-4 for speed and structure. I chose Claude because the output reads better.
Voice consistency: Include style samples in your prompt. Don't just say "write like a blogger." Paste 2-3 examples of your actual writing.
Fact-checking automation: Don't. Manual fact-check is the only reliable method. Building automated fact-checking is fragile and creates false confidence.
Iteration: Build it. Launch it. See what breaks. Your first version will be wrong about something. That's normal.
How to Build Your Own Version
High-level steps:
- Set up a Make.com account (free tier is fine for starting).
- Create a form (Typeform, Google Forms, custom HTML—all work). Form has fields: keyword, optional notes.
- Webhook from form to Make.com. When form submits, Make.com receives the data.
- First Make.com module: Claude API call for the outline. Format the response as structured data.
- Second Make.com module: Claude API call for the full post, using the outline.
- Text manipulation: Clean up formatting, add metadata, generate meta description.
- Email delivery: Make.com sends the result to the user.
- Optional: Database logging (store what was generated, track usage).
Total setup time: 4-6 hours if you're comfortable with APIs. 8-12 hours if you're new to Make.com and need to learn the interface.
Total ongoing cost: $0.10 per post in Claude API calls + $25/month Make.com subscription (or free if you stay under 1,000 operations/month).
The Honest Verdict
Automatic content generation is real and works. It won't replace human writers, but it's genuinely useful for creating first drafts fast. The key is understanding that a 40% finished draft you can edit is more valuable than a 0% blank page.
Build it yourself if you can. SaaS tools are expensive and lock you in. Three hours with Make.com and you own the entire system.