Duck
Tutorials9 min read

How to Automate Content Creation With AI (The Operator's Playbook)

Samet Turan— Editor··9 min read

Learn how to automate content creation with AI using a production-ready system. This guide covers the toolchain, multi-step prompts, and debugging for a real content pipeline.

The Core Components of a Real AI Content Pipeline

Forget the one-click-to-article fantasy. A real AI content system isn’t a single magic box; it’s a pipeline of specialized agents. Each part does one job well. I’ve built these for my own businesses and for clients, and they all share the same five-part structure. Thinking in these components is the first step to building something that doesn’t fall over.

  • 1. The Trigger: This is what kicks off the process. It could be a new row in a spreadsheet, a webhook from a form, or a scheduled timer. For content, my go-to trigger is a new record in an Airtable base with a ‘Status’ field set to “Ready for AI”. Simple, manual, and reliable.
  • 2. The Data Source: This is your ground truth. The AI needs input. At a minimum, it’s a primary keyword. A better source includes a target audience, a desired tone, and maybe a few competitor URLs for inspiration. This data lives in the same Airtable record as the trigger.
  • 3. The LLM Core: This is the brain. It’s one or more API calls to a Large Language Model like GPT-4o or Claude 3 Sonnet. Notice I said “one or more.” The key to quality is breaking the task down into a chain of prompts, not a single monster prompt. We’ll get to that.
  • 4. The Formatter: Raw text from an API is useless. You need a dedicated step to turn that wall of text into clean HTML. This agent adds `

    ` tags, `

      ` lists, and `` emphasis. It’s a separate, specific instruction.
    • 5. The Publisher: This is the final step where the formatted HTML is sent to its destination. This could be creating a new draft post in WordPress, Webflow for landing pages, or Ghost via their respective APIs.

    Your orchestrator ties all this together. It’s the software that runs the workflow. I use Make (formerly Integromat) for its visual interface, but n8n is a fantastic open-source alternative if you prefer to self-host. The orchestrator is the factory floor where your agents work.

    What Most Guides Get Wrong About AI Content

    Almost every tutorial on this topic starts with a fundamental, fatal flaw. They show you a single prompt. Something like: “Write a 1500-word blog post about [topic] in an engaging tone.”

    🤖
    Recommended Reading

    AI Side Hustles

    12 Ways to Earn with AI

    Practical setups for building real income streams with AI tools. No coding needed. 12 tested models with real numbers.


    Get the Guide → $14

    ★★★★★ (89)

    This is a recipe for generic, soulless garbage.

    Honestly, any guide that shows a single prompt is selling you a fantasy. One-shot generation doesn’t work for anything serious because it asks the model to do too many things at once: research, structure, write, format, and maintain a persona. The model will fail at most of them, averaging down to predictable mush. You get the same intro-body-conclusion structure every time, filled with platitudes.

    The correct approach is a multi-agent, or “chain of thought,” system. You use a sequence of smaller, more focused prompts that build on each other. An ‘outline agent’ first creates the structure. A ‘drafting agent’ then writes the content for each section of that outline. A ‘formatting agent’ cleans it up for publishing. Each step’s output becomes the next step’s input. This mimics how a human writer works and gives you control points to fix things when they go wrong. It’s more work to set up, but it’s the only way to produce content that doesn’t scream “I was written by a robot in 2026.”

    Step-by-Step: Building Your Keyword-to-Draft Engine

    Let’s get practical. Here’s a simplified version of the workflow that generates a draft from a keyword. This assumes you’re using Make.com as the orchestrator and the Anthropic API for Claude 3 Sonnet.

    1. The Trigger: Airtable. Create a base with fields for `Keyword` (text), `Status` (single-select), and `Generated_HTML` (long text). Your Make.com scenario starts with the “Watch Records” module for Airtable, configured to run when a record’s `Status` is updated to “Generate”.
    2. Agent 1: The Outliner. Add an Anthropic “Create a Completion” module. This is your first AI call. You’re not asking for an article; you’re asking for a plan. The prompt should be specific.

      System Prompt: You are a content strategist. Your job is to create a detailed, logical outline for a blog post.

      User Prompt: Create a comprehensive blog post outline for the primary keyword "{keyword from Airtable}". The outline should include an introduction hook, 4-6 main H2 sections with 3-5 bullet points under each one detailing the key topics to cover, and a concluding thought. Output ONLY the outline and nothing else.

    3. Agent 2: The Drafter. Add a second Anthropic module. Its input is the keyword from Airtable and the outline from the previous step. This is where the prose gets written. The prompt is now much more constrained.

      System Prompt: You are an expert writer in a clear, direct, and opinionated style. You write for an audience of operators who value practical advice. Use contractions. Vary sentence length.

      User Prompt: Write a full blog post based on the following keyword and outline. Adhere strictly to the structure provided in the outline. Write the content for each section. Do not invent new sections. Do not write a generic intro or conclusion. Just write the content as requested.

      Keyword: "{keyword from Airtable}"
      Outline: {output from Agent 1}

    4. Agent 3: The HTML Formatter. The output from Agent 2 is a wall of text. Add a third Anthropic module to clean it up.

      System Prompt: You are an HTML formatting assistant. You only output clean, valid HTML. You do not alter the text content.

      User Prompt: Convert the following blog post text into simple HTML. Use only `

      ` for main headings, `

      ` for paragraphs, `

        ` and `

      • ` for bullet points, and `` for bolding key phrases. Do not add any other tags, styles, or attributes.

        Text: {output from Agent 2}

      • The Publisher: Update Airtable. Add a final “Update a Record” module for Airtable. Take the HTML output from Agent 3 and write it into the `Generated_HTML` field of the original record. Change the `Status` to “Draft Ready for Review”.

    Now you have a semi-automated system. You add a keyword, set a status, and a few minutes later a complete HTML draft appears, ready for a human to review, edit, and publish.

    Is the API Cost Worth It for Solo Operators?

This is a fair question. When you move from ChatGPT’s flat monthly fee to a usage-based API, it feels like the meter is running. So, let’s run the numbers. A 1500-word article generated through the chain above might consume around 5,000 input tokens and 25,000 output tokens across all three calls (drafting is the most expensive part).

Using the OpenAI API for GPT-4o, that’s roughly $0.15. Using the Anthropic API for Claude 3 Sonnet, it’s about $0.45. Let’s be generous and say it costs a dollar per article to account for testing and longer pieces.

My opinion? The API cost is a rounding error. It is ridiculously cheap. A human writer of decent quality will charge you $150-$500 for the same article. The automation buys you a first draft for less than the cost of a coffee. Your time spent editing that draft is the real currency, not the pennies spent on API calls. The $29/mo I pay for a Make.com plan (which can run dozens of these workflows) is a much more significant cost, and even that is a bargain.

My one concrete gripe with this model is a universal one for API-based systems: cost control. If a prompt goes wrong or gets stuck in a loop (which can happen with buggy webhooks), you can rack up a surprise bill. It’s never been catastrophic for me, but getting a $50 bill when you expected $5 is annoying. Setting up billing alerts in your OpenAI or Anthropic account is the first thing you should do.

How to Debug When Your AI Content Engine Breaks

It will break. Automation is not a one-time setup; it’s a system you maintain. Here are the most common failure points and how to fix them.

  • Problem: The tone is bland and repetitive.
    Fix: Your system prompt for the drafting agent is too generic. Beef it up. Give the AI a persona. Tell it who it’s writing for. Example: “You are a former CTO who now runs a solo consultancy. You are skeptical of hype and give direct, no-nonsense advice. You use short sentences and are not afraid to state a strong opinion.”
  • Problem: The AI hallucinates facts or makes things up.
    Fix: Your prompt is too open-ended. You need to ground it. Instead of just giving it a keyword, the ‘Research Agent’ step should also pull in real information—like the top 3 search results for the keyword or snippets from a technical document—and instruct the ‘Drafting Agent’ to base its writing on that source material.
  • Problem: The HTML formatting is a mess.
    Fix: Your formatting prompt isn’t strict enough. You need to use negative constraints. Don’t just tell it what to do; tell it what *not* to do. For example: “Use only these tags: h2, p, ul, li, strong. Do NOT use h1, h3, div, span, or any inline styles.” This is where I have my concrete love for tools like Make.com: the execution log. I can inspect the exact input and output of every single module. Seeing the raw, messy text the LLM sent to my formatter was how I figured out I needed to be more explicit with my negative instructions. Without that log, I’d just be guessing.

Beyond Text: Automating Images and Internal Linking

Once your text-to-draft engine is running smoothly, you can add more agents to the chain. The process is the same: add a new module in your orchestrator with a specialized prompt.

A common next step is an ‘Image Agent’. After the HTML is generated, you can make another API call to a model like DALL-E 3. You’d use the article title or a summary to generate a prompt for a relevant featured image. The image URL is then saved back to another field in your Airtable record.

A more advanced operator playbook involves an ‘Internal Linking Agent’. This is a script that scrapes your own website’s sitemap to get a list of all existing articles and their URLs. You feed this list, along with the new draft, into an LLM and ask it to identify 3-5 opportunities to link from the new article to existing ones. It then provides the exact anchor text and URL, which can be programmatically inserted or added to a ‘suggestions’ field for the human editor.

This is how you move from simple text generation to building a genuine content automation platform that handles multiple parts of the publishing workflow. It’s an iterative process, not a single project.

We cover this in more depth elsewhere — deeper coverage of AI agent platforms.

Building this yourself is a great way to learn the nuts and bolts. But if you’d rather skip the build and deploy a working version in an afternoon, we’ve packaged this entire workflow as an AI automation blueprint at deepusecase.com/vault.

— The Colophon

One AI tool. Tested. Reviewed.
In your inbox every Sunday.

~3 minute read. Real outcomes from operators, not marketers.

Free. One email per Sunday. Unsubscribe in one click.