How to Automate Content Creation: A Follow-Along Guide

When people hear “automated content creation”, I imagine they picture something like this: Enter a keyword, click a button, and poof! An article is made. From there, they’ll generate 500 articles before the day ends and publish all of them.

I don’t want to say these systems don’t exist. They do. In fact, we’ve even made one. But our content cadence has remained the same.

Because it’s not our goal at Ahrefs to contribute even more spam and slop to the Internet.

Yes, we want to make more content. But we want to make more useful content. More better content. Not simply more content.

Automation can help: not by replacing the interesting parts of content marketing, but by freeing us from the boring ones.

Because I love making content that helps people and promotes our brand. But let’s be real: Not every part of content marketing is equally enjoyable. Some parts are really, really, really boring. Unfortunately, they’re also important.

Take updating content.

Google loves fresh content. When its Query Deserves Freshness (QDF) algorithm detects that a topic needs current information, it boosts recently updated pages. Likewise for AI assistants. Our study found that compared to traditional search results, AI assistants prefer citing fresher content.

Updating is easy enough when you have one article. Not so easy when you have dozens. Or hundreds.

That was the problem I had. Over the years, I’d created a collection of data-driven articles like our top Google searches and most searched questions. Having to update all of them was a giant chore.

So I built something I call the Data Refresh Hub.

Every month, it:

In other words, the machine now does most of the boring work.

This guide will show you how I built it and, more importantly, how you can apply the same process to the annoying content tasks you wish would disappear from your own to-do list.

If you want to build your own automation while reading this guide, you’ll need a few things:

Don’t worry if you don’t have all of these yet. Part of this guide is figuring them out.

You will, however, need to decide which AI agent or automation platform you want to use.

I chose Letaido because it had everything I needed in one place:

The last point was important for me because I didn’t want to build an automation that did 90% of the work, only for me to spend the final 10% copying tables from one tool and pasting them into WordPress every month. Which defeats the purpose.

You can, of course, use your favorite agent instead. Claude Code, Codex, or whatever else you prefer.

You may just have to do some extra work connecting MCPs, WordPress, databases, or whatever other systems your workflow depends on.

Don’t start by asking: How can we use AI?

I think this is where a lot of companies go wrong. The question is so open-ended that you end up staring into an infinite universe of possibilities. And when there are infinite possibilities, people don’t necessarily dream bigger.

They get a headache.

Then they go back to whatever they were already doing. Instead, start with your biggest existing frustration.

What is something you already have to do that you wish you didn’t?

If nothing immediately comes to mind, list the work that happens every week, month, quarter, or every time a piece of content gets produced.

Then look for tasks that are:

For me, one obvious candidate was updating our data-driven articles.

These articles were most useful when the numbers were current. They also tended to get the most search traffic when we updated them.

But every refresh required me to:

If I had one article, this would have been fine. But the collection kept growing.

Eventually, updating everything monthly became unsustainable. So we compromised and moved to quarterly updates, even though monthly would have been better for readers.

An agent cannot reliably automate a process that nobody can explain.

This sounds obvious. It isn't. Most of us do repeat tasks on autopilot, and autopilot is terrible at explaining itself.

So before you build anything, reconstruct how you actually do the job. I don't mean how you think you do it, or how it's written in an SOP nobody has opened in years. I mean how you really do it, including the shortcuts.

Record every meaningful action. That includes the small things and the corrections that are easy to forget.

Here's roughly what my process for updating Top Google Searches looked like once I wrote it all down:

As you can see, there are a lot of little decisions here and there that you likely won’t remember off the top of your head because it comes so naturally to you. Writing them down is how you find them.

A pro tip I can give you is to ask the agent to interview you.

Try something like:

You’ll probably discover you have a lot more unwritten rules than you thought.

Once you have that checklist, don’t leave it sitting in a doc. Turn it into a skill file: a saved set of instructions your agent follows every time it runs the job, so you write the process down once and never have to re-explain it. I’ve covered how to build one in our guide to Claude Skills.

I wouldn’t rely on an LLM’s memory or generic web search for information that matters to your workflow.

LLMs are known to make up numbers and web search tends to pull from whatever it finds. That could be a listicle from five years ago or even AI slop. Hardly worth trusting.

You want to tell the LLM which sources it should use. Then connect those sources to it, whether through an MCP, an API, or uploaded files.

Depending on what you’re creating, that might include:

For my Data Refresh Hub, different articles require different sources. Here’s where everything came from:

The rule of thumb: the LLM's job is to process the data, not to be the data.

Instructions are useful. Examples are better.

If your workflow involves judgment calls, give the system examples of:

Your goal is to turn recurring editorial decisions into explicit rules.

For example, Top Google Questions is supposed to be a list of, well, questions. The simplest rule would be "keep anything that starts with who, what, where, when, why, or how."

Sounds simple. Except lots of queries start with a question word and aren't questions at all:

Sometimes the LLM won't catch these right away. It sees "how" at the start and a sensible-looking phrase after it. A human (me) needs to tell it explicitly why these shouldn't be accepted.

Fortunately for me, Letaido was capable enough to spot it:

This is where the reasons matter. If I only say "reject How to Train Your Dragon," the model learns one exception. If I say "reject titles of movies, TV shows, books, and songs, even when they're phrased as questions," it learns a rule. Now it can also catch something like How to Lose a Guy in 10 Days without me ever mentioning it.

Most Searched People had a different problem.

This one was harder, because we don't have that data in Ahrefs. There's no ready-made list of "people" to pull from. So I needed the LLM to analyze the data we do have and pull out the entities that belong to a person.

That's harder than it sounds. Is "Jordan" a basketball player, a country, or a pair of sneakers? Should "Taylor Swift tickets" count toward Taylor Swift?

I decided in the end that only name searches should count.

Finally, whatever you do, make the system keep what it rejected, not just what it accepted, along with the reason.

That rejected list is your early warning system. If a genuine question ever ends up in there, you'll spot it in seconds and fix the rule. If you only see the final output, you'll never know what went missing.

At this point, it’s tempting to automate everything. Don’t.

Always start with one thing first.

For example, I made sure the automation worked perfectly for Top Google Searches before I even thought about expanding it to everything else.

It's tempting to go big. You've done all this prep, the agent seems smart, why not point it at all 12 datasets at once?

There’s a very practical reason for this: You want to catch all its mistakes before anything goes live. And it's a lot easier to catch mistakes in one output than in 12. If all 12 are wrong, you don't even know where to start looking.

Starting small also lets you gradually define what the system is and isn’t allowed to change.

For example, I originally only wanted the tables changed.

Nothing else. Because I was afraid that if I asked the agent to improve the article, it’ll make a mess. Em dashes, AI-isms, and the like.

Once I was satisfied with what it did (and not immediately, over the course of 2-3 months), I then started to allow it to make bigger changes.

For example, the first line in this intro is now “programmatic”, in the sense that it’ll change according to what the top searches are in the table.

Another example: This image also generates each time the table is updated (across all the different posts for the different platforms):

I’ve started playing around with how to improve the tables to have more interesting data and also help the reader:

I also recommend generating an output at every major stage of the workflow.

This setup has saved me more times than I can count. If there's a mistake, I don't have to restart the whole thing from the top. I check each output, find the stage where things went wrong, fix it, and rerun from there.

Ideally, it should also keep all the data it has changed or updated over time. Mine does. That means I'm building a historical dataset every month. In the future, I can use it to make charts and sparklines that show how searches change over time. That's content nobody else can make, because nobody else has the data.

Finally, the one rule for myself: I never let AI publish automatically for me.

However good the automation gets, we need a human in the loop to keep an eye on things, just in case anything goes wrong. And eventually, something always does.

More than that, someone needs to be responsible for what goes live.

I think of it like being the head chef at a world-class restaurant.

The head chef may not personally cook every single dish anymore. They have sous chefs, line cooks, pastry chefs, and an entire team doing the work.

But everything that leaves the kitchen goes out under their name. If a customer gets a bad plate, it's the head chef's reputation on the line. So they check every dish before it's served.

Your automation is your kitchen. You're the head chef now. Nothing should leave without your sign-off.

Once your one piece works in testing, run the whole thing for real, from start to finish, exactly as it would run on its own.

Then compare the output with your human-made version, side by side. Here's what I'd check:

Keep this question in mind: Would I have published this if I'd made it myself?

When everything looks good, set up a schedule (e.g., monthly).

A couple of things to think about here:

When you're happy with the workflow, it's time to expand it.

That's what I did. Once I was happy with everything coming out of Top Google Searches, I rolled it out across all the other posts I wanted to update, one at a time.

Yes, it takes a while. Each new article has its own quirks. Most Searched People needed completely different rules from Most Expensive Keywords. But remember: it's easier to fix one thing than everything at once. And every article you add gets easier, because most of the pipeline is already built.

But in my case, I didn't just scale up my own workflow. I shared the process with the team, and it inspired them to build things too.

For example, Louise started using the same process to update her articles, like fastest-growing SaaS companies.

So "scaling it up" doesn't just mean scaling your own processes. It can mean scaling it across your entire department, or even the entire company.

That's how true AI adoption happens. Not by sending a company-wide memo saying "use AI more." That just produces anxiety and a lot of ChatGPT tabs. It happens when someone builds something that works, shows it to their colleagues, and they go: "Wait, can I do that for my thing too?"

So is it over once you've set up the automation? Can you finally be in Bali sipping cocktails while AI does all your work?

Unfortunately, no. The last I checked, I’m still in London.

Human review is still necessary. And because AI keeps changing and improving, your automations will break.

For example, when Anthropic released Opus 5, it broke Compound Engineering, an extremely popular plugin:

If a popular, well-maintained plugin can break overnight, your homemade automation definitely can.

Here’s my own personal example: I built my automation in the same workspace as our content team. Ryan added a new secret or bridge for their own workflows, but unknowingly broke my automation.

Here are the things most likely to go wrong:

So you’ll have to keep on maintaining your automations and making sure everything continues to work well.

Again, back to the same restaurant analogy: Even as a chef climbs the ranks, they don't stop checking in on their sous chefs and junior chefs. Recipes get tweaked, suppliers change, new staff join. So they keep tasting, keep checking, and keep correcting, so every dish on the menu comes out perfect.

Same with your automations.

I think the least useful way to approach automated content creation is to ask how AI can make as much content as possible.

We already have enough content.

The better question is:

What parts of making genuinely useful content are stopping us from doing more of it?

Get AI to handle the boring parts, so you can spend your time on the parts that actually need you: the ideas, the opinions, the experience, the taste. The stuff no model can fake.

That should be the future of working together with AI on content.