Semrush Rebuilt Its Content Pipeline in Claude Code — the Transferable Part Isn't the Prompts

Semrush has thousands of blog posts about SEO, AI visibility and content, and a backlog of them going stale. Updating one isn't writing — it's an audit plus a surgical rewrite: what's outdated, where competitors moved, what the AI search landscape now expects, which product capabilities to mention, and how to change all that without breaking the parts that still rank.

They built an automated pipeline for it in n8n. The research half worked. The drafting half never did. So they rebuilt it in Claude Code, and published what changed.

The useful part isn't the prompts. It's the architecture — and one line about why n8n was the wrong shape for the job.

Where the n8n version broke

The research stage was fine. n8n pulled SERP data, competitor articles, domain intelligence scans, AI Overviews, related searches and internal linking opportunities. That's chaining API calls, which is exactly what n8n is for.

Drafting is where it fell apart, and the failure description will be familiar to anyone who has tried this:

The drafts came back somewhat close to what I was looking for, but never close enough to publish.

Wrong voice. Style guidelines ignored. Verbose. And hallucinations — the model described Semrush features that don't exist, in convincing detail. The team tried the usual remedies: different models, tighter prompts, splitting steps into smaller ones, feeding in style guides and examples. None of it produced consistent results.

The diagnosis they landed on is the sentence worth taking away: n8n is excellent at chaining API calls and has no editorial reasoning. Piping a style guide through an API call as text is not the same as an agent that can open the style guide, the original article, and the competitor research while it writes.

That's the actual dividing line between the two tools, and it generalises well beyond content. If your step needs judgement applied across several reference documents, a workflow node passing strings around is the wrong container. We made a version of this argument about where automation stops and agency starts in MCP explained simply.

The rebuild: nine skills, chained by a script

The Claude Code version is nine skills run in sequence by a master script:

1. Fetch the live article
2. Research SERP and competitors
3. Run a semantic similarity check
4. Synthesise an update plan
5. Identify outdated content
6. Audit product mentions
7. Draft the updates
8. Generate a side-by-side comparison with changes highlighted
9. Format for publishing

You give it an article URL and a target keyword. You get back a draft plus the artifacts — research, plan, comparison.

Note what steps 5, 6 and 8 are doing. They aren't writing. Identify outdated content, audit product mentions and generate a side-by-side diff are verification steps, and they're roughly a third of the pipeline. That ratio is the tell of a workflow built by someone who has been burned.

The pattern worth stealing: files between steps

Here's the piece to copy even if you never write a word of marketing content.

Each skill saves its work to a file before the next one runs. Every stage leaves an artifact behind, and any skill can be re-run independently against those artifacts.

Three things fall out of that, all of them valuable:

• Re-running step 6 doesn't mean re-running steps 1 through 5. If the product audit is wrong, you fix and re-run that stage against research you already paid for. In a monolithic prompt, one bad output means starting over.
• The intermediate state is inspectable. When output is wrong you can open the research file and the plan file and see which stage went wrong. Not "the AI got it wrong" but "step 4 built a bad plan from good research."
• It's an audit trail. Every draft comes with the evidence that produced it.

This is the same argument as writing to disk rather than holding everything in context, and it's why the pattern shows up in serious agent workflows regardless of domain — it's what makes reviewable, verifiable output possible instead of a black box you either accept or discard.

Hallucinations didn't stop. They got cheap to catch.

The best detail in the whole write-up is that hallucinations still happened after the rebuild.

A contributor hit a plausible-looking instruction for a feature that didn't exist. Under the old process, verifying it meant cross-checking against the source — about twenty minutes. With the side-by-side diff against the original article, she spotted and fixed it in roughly one minute.

That's the realistic goal, and it's worth stating plainly because so much AI tooling is sold on the opposite promise. The pipeline didn't make the model stop inventing things. It made invention obvious. A twenty-fold cut in the cost of catching a specific class of error is a better outcome than a claim that the error no longer occurs — because the claim isn't true of any current model, and a workflow built on it will ship the mistakes.

Design your pipelines for cheap detection, not for the absence of errors. The same logic underpins auditing AI-generated code before it ships.

What still belongs to a human

The team is direct about this: they make every editorial call. Contributors review drafts for factual accuracy, edit for clarity, handle revisions and add images through the normal editorial workflow.

Notice that the pipeline ends at format for publishing, not at publishing. Nine automated steps produce a draft and the evidence for it. A person decides whether it's true and whether it's good. That division — machine assembles, human judges — is the same one we described in the developer's new job.

What to take from it

• Match the tool to the reasoning required. API orchestration and editorial judgement are different problems. A workflow engine that's great at the first can be structurally unable to do the second, and no amount of prompt tuning fixes a container mismatch.
• Give the agent file access to its references. The breakthrough wasn't a better prompt; it was moving the work somewhere the model could read the style guide, the original and the research directly.
• Persist state between steps. Files as the interface make stages independently re-runnable, debuggable and auditable.
• Budget a third of your pipeline for verification. Identify-outdated, audit-claims, and diff-against-original earn their place.
• Optimise for catching errors, not preventing them. A one-minute check beats a twenty-minute one far more reliably than a promise of no errors.
• Iterate, and expect it to take a few passes. Consistent voice and structure arrived after three rounds of small adjustments — not on the first run.

Worth noting the cost dimension too: nine skills over hundreds of articles is not free, and a pipeline that re-runs stages is exactly the shape that quietly consumes tokens. Our breakdown of the hidden costs of AI coding applies directly.

Bottom line

A content team hit a wall with an automation tool, correctly diagnosed the wall as structural rather than a prompting problem, and moved the work to an agent that could read its own reference material. The rebuild is nine skills passing files to each other, a third of them dedicated to catching mistakes, ending in a draft that a human still has to approve.

If you're building anything agentic, the transferable lessons are the artifact pattern and the reframing of hallucination from a problem to be eliminated into a cost to be reduced. The second one is the harder shift, and the more useful.

For what changed in Claude Code itself recently, see our coverage of the browser, artifacts and iOS simulator update.

Sources

• Semrush — I rebuilt our content update pipeline in Claude Code. Here's why. (25 June 2026) semrush.com