How We Run a Content Business With No Writers: AI Automation From Idea to Published

Most content teams spend more time managing the process than actually producing. Briefs, drafts, edits, approvals, formatting, publishing — it stacks up fast. The average blog post takes 3-4 hours to produce when you factor in everything. We got that down to under 15 minutes, end to end, with zero human writers in the loop.

This isn't a pitch for AI writing tools. It's a breakdown of an actual automated content pipeline we built and run at systemsbyai.ai — from the moment a topic gets selected to the second a post goes live and gets cross-posted to X. Every step is triggered, automated, and logged. Here's exactly how it works.

Step 1: Topic Selection That Runs on Autopilot

The pipeline starts with a Google Sheet that functions as a content queue. Topics get added either manually when we spot something worth covering, or automatically via a webhook that pulls trending queries from a keyword monitoring tool we have running in the background.

Each row in the sheet holds a topic, a target keyword, an assigned content category, and a status field. When a row gets marked 'Ready,' a Make.com automation picks it up. That single trigger kicks off the entire downstream process. No one has to remember to start anything. The queue feeds the machine.

We review the queue once a week — maybe 10 minutes — to make sure nothing nonsensical slipped in. That's the only human checkpoint before content starts generating.

Step 2: AI Drafting With a Repeatable Prompt Stack

Once the trigger fires, Make.com sends the topic, target keyword, and category to OpenAI via API. We're not using a single massive prompt. We use a structured prompt stack — one prompt for generating an outline, a second for drafting each section, and a third for writing the meta description and title variants.

The prompts are stored in Airtable and versioned. When we want to change tone, update formatting rules, or improve output quality, we edit the prompt record — not the automation itself. That separation keeps the system stable while letting us iterate fast.

Output quality matters here. The prompts are engineered to match our voice, enforce structure, and produce content that's useful rather than generic. We've gone through probably 40 iterations of the core draft prompt since we started. That investment compounds — every post after the improvement benefits from it.

The full draft, meta description, and suggested title come back as a structured JSON object. That object passes directly into the next step without any manual reformatting.

Step 3: SEO Optimization and Static Site Publishing

The JSON output from the AI drafting step feeds into a lightweight SEO formatting script we built. It checks keyword placement in the title, first paragraph, and at least one H2. It also flags posts where the meta description is too long or the content is under a minimum word count. If something fails the check, the automation routes it to a Slack notification for a quick human review — but this happens maybe once every 20 posts.

For publishing, we use a static site generator. The automation formats the content into a markdown file, adds frontmatter with the title, date, category, and meta fields, then commits the file to a GitHub repo via the GitHub API. Our CI/CD pipeline handles the rest — it detects the new file, builds the site, and deploys to production in under two minutes.

No CMS login. No copy-paste. No formatting in a WYSIWYG editor. The post goes from AI output to live URL without a human touching it.

Once the deploy webhook fires confirming the post is live, the automation grabs the live URL and passes it to the cross-posting step.

Step 4: Cross-Posting to X and Performance Logging

With the live URL in hand, a separate Make.com module calls OpenAI again — this time with a short prompt to generate a punchy tweet that matches the post's angle. It's not a summary. It's written to perform on X: direct, specific, and formatted with a clean link.

The tweet gets posted automatically via the X API. We have basic rate-limit handling built in so nothing breaks during high-volume days.

The final step is logging. Every published post writes a row to a Google Sheet that tracks the URL, publish date, target keyword, word count, and the tweet text. Once a post has been live for 7 days, a scheduled automation checks Google Search Console via API and pulls impressions and click data back into that same row.

That closing the loop is the part most people skip. It's also the most valuable part — it tells you what's actually working so you can feed better topics into the front of the pipeline.

The whole stack runs on Make.com, OpenAI, GitHub, and a few Google Sheets. No custom software. No engineering team. The build took about two weeks and it's been running with minimal maintenance since. The only reason to touch it is to make it better — and because all the logic lives in prompts and sheet configs, making it better is fast.

If you're running a content operation and still doing any of this manually, you're not behind on AI tools — you're behind on systems. The tools exist. The question is whether you've connected them into something that actually runs.