I Rebuilt 500+ Blog Posts for AI Search with Claude Code

Search stopped being ten blue links. A growing share of discovery now happens inside ChatGPT, Perplexity, Claude, Gemini, and Google's AI Overviews — engines that don't rank your page, they cite it or they don't. I had 500+ posts live that were built for the old game. So I rebuilt them for the new one, with Claude Code agents, without hiring anyone. This post is the pipeline, the numbers, and — most importantly — the QA gates that kept 506 posts from being 506 pieces of garbage.

What an AI SEO content engine actually is#

It's not "AI writes blog posts." It's three things bolted together:

1. A written per-post standard the agents load before touching anything — structure, schema, linking, and truth rules encoded as an executable procedure, not vibes.
2. Batch execution — agents work a queue of posts, each producing a small reviewable diff.
3. Verification as a separate pass — a different check, run after generation, that validates schema, links, and framework compliance before anything ships.

Remove any one of the three and you get drift, spam, or both.

Why "GEO" is a different job than SEO#

Generative Engine Optimization is optimizing to be cited by AI engines, not just ranked by Google. The two overlap heavily — clean structure, real expertise, crawlable pages help both — but GEO adds its own requirements: passage-level answerability (can an engine lift a self-contained, correct answer from your page?), machine-readable structure, and the blunt prerequisite that AI crawlers can reach your site at all. I keep a running checklist of what actually gets a page cited by AI engines — the short version is that engines quote pages that answer in liftable passages and skip pages that make them work.

One thing I learned the hard way: AI-search parameters change monthly. My working framework has a mandatory step — fresh research on the current per-engine rules before every batch, then apply. A GEO playbook frozen in time quietly rots.

The run, in real numbers#

This was one overnight run against a photography brand's blog, executed entirely on a preview branch — production was never touched until the final deploy.

The gap between 520 processed and 506 shipped is the QA gates doing their job. More on those below.

The pipeline: clone, don't freelance#

The single most important architectural decision: new posts are never designed from scratch — they're cloned from a real, live post. The generator curls an actual production post, captures its full markup — header, hero, story sections, FAQ accordion, gallery, author bio, related posts — and swaps content into that shell. Earlier I let an agent build a post "in the brand's fonts" instead of from the brand's template, and it got rejected on sight: wrong layout, wrong theme, sideways images. The correction became a standing rule: the live template is the law, and the captured copy of it lives inside the skill the agents load.

On top of the cloned shell, every post gets the per-post framework:

Structure. A direct answer to the core question near the top, in a liftable self-contained passage. Question-shaped H2/H3 headings. Lists and tables where the content is genuinely list- or table-shaped — AI engines quote structured passages far more readily than walls of prose. An FAQ block for the queries people actually ask.

Schema. JSON-LD on every post — Article markup with a real author entity, FAQPage where there's an FAQ, breadcrumbs. Schema is how you tell machines what a page is instead of hoping they infer it.

E-E-A-T. Experience, Expertise, Authoritativeness, Trust — demonstrated, not claimed. Real author attribution with a real bio. First-hand operational detail a content mill couldn't fake. Honest dates. For my brands this part is natural, because the posts describe work I actually did; the overhaul's job was making that experience visible to engines.

Internal links. Every post links to its siblings in the topic cluster with descriptive anchor text, so crawlers and AI engines see a connected body of expertise instead of orphan pages. (You're inside one of those clusters right now — on purpose.)

Image rules. Images follow the story, not the CSS. Side-by-side images must read left-to-right in narrative order — never CSS-columns masonry, which flows down columns and scrambles the sequence. Only same-orientation neighbors get paired; mixed pairs run full-width solo, so there are never black gaps and never reordering to force a pair. EXIF orientation gets baked in physically before publish, because preview extractions silently lose it — I learned that from a run where hundreds of vertical frames came out sideways. And every post gets a deliberate scroll-stopper thumbnail, never a generic frame.

The QA gates that kept 506 posts from being garbage#

Volume is easy. Volume that survives scrutiny needs gates. These are the ones that ran, in order of severity:

Gate 1 — the truth gate. Old posts had no recoverable original story text, not even on the legacy mirror. The tempting move is to let the model invent a plausible narrative. The rule instead: leads are built only from verifiable facts — the real title, venue, city, and names already on the page. Fact-derived, never invented. Result across 520 posts: zero fabricated claims.

Gate 2 — the consent gate. One client had signed a formal no-publish addendum. That session was hard-excluded from the pipeline, and the workflow now includes a mandatory inbox opt-out check before publishing any client work. No SEO win is worth publishing someone who asked not to be published.

Gate 3 — the real-posts gate. Dev artifacts — template clones, test pages, half-built drafts — live in the same directory as real posts. An explicit allowlist file defines what counts as a real post; everything else is excluded from the build. Without it, the engine would have happily GEO-optimized test pages into production.

Gate 4 — separate verification. After generation, a distinct pass validates schema, checks that links resolve, and confirms the framework was actually followed. Generation and verification are never the same step — an agent grading its own homework passes itself. I wrote up why this gap is where most agent deployments fail in the verification gap.

Gate 5 — staged rollout. Everything ran on a preview branch with its own deploy URL. Production shipped once, after review, with the rollback deploy ID recorded before pushing. That preview-first, rollback-ready discipline is now its own written procedure — the safe-rollout playbook — because a content engine that can touch production without a gate is an outage generator.

The infrastructure half#

On-page work is wasted if machines can't reach or hear about your pages.

AI-crawler access. Many sites block GPTBot, ClaudeBot, PerplexityBot and friends at the firewall or robots.txt level — sometimes by default, without anyone deciding to. Step zero of a GEO overhaul is auditing that and unblocking the AI crawlers you want citations from. You cannot be cited by an engine that has never read you.

IndexNow. Instead of waiting for crawlers to rediscover changed pages, IndexNow pushes every new and updated URL to participating engines the moment it changes. When you're touching 500+ posts, active notification versus passive waiting is the difference between weeks and days.

Fast, static delivery. Static HTML on globally cached edge hosting. Crawl budget goes further and every fetch is cheap — which matters when you've just invalidated your entire archive.

The workflow, step by step#

For overhauling an existing blog of any size:

1. Inventory. Crawl your own site. Build a list of every post with URL, title, word count, existing schema, and internal links. This is the work queue and the progress tracker.
2. Fresh rules research. Research current citation behavior per target engine. Mandatory per batch — the rules move.
3. Capture the template. Curl a real live post and make its markup the shell every generated post fills. No freelancing layouts.
4. Write the framework as an executable procedure. Structure, schema, E-E-A-T, linking, image rules — one document the agent loads for every post.
5. Install the gates. Truth rules, consent check, real-posts allowlist — before the first batch runs, not after the first incident.
6. Unblock the crawlers. Audit robots.txt, firewall, bot protection. Fix before rewriting anything.
7. Batch through the queue. Restructure headings, add the liftable answer passage, inject schema, wire internal links. Each post is a small, reviewable diff.
8. Verify separately. A second pass validates schema, resolves links, confirms compliance.
9. Ship staged. Preview branch → review → one production deploy with a recorded rollback ID.
10. Push via IndexNow and sitemap, then track. Watch indexation and AI-engine citations; feed learnings into the next batch's framework.

What it took, and what it feeds#

One operator, Claude Code agent fleets, one written framework, one overnight run — 506 posts live. The same standard now feeds the always-on layer: a daily content engine that runs across five brands on a schedule, analytics-gated, so the archive keeps growing under the same rules without me in the loop per-post.

The meta-lesson is bigger than blogging. Any large archive — docs, product pages, help centers — built for yesterday's discovery layer can be systematically rebuilt for today's, if you turn the standard into an executable procedure, put an agent fleet behind it, and gate it like you mean it.

FAQ#

Is 500+ AI-processed posts just spam at scale?#

Volume without a standard is spam. Volume under an enforced framework — real structure, real schema, demonstrated first-hand experience, fact-derived claims only, a consent gate, and a separate verification pass — is a content operation. The framework is the difference, and it's written down and executed identically on every post.

What's the minimum viable version?#

Unblock AI crawlers, add a direct liftable answer near the top of your key pages, add Article/FAQ schema, and set up IndexNow. That's a weekend of work and covers the largest gaps most sites have.

How do you keep the engine from fabricating facts?#

A hard truth gate: generated copy may only be built from verifiable facts already attached to the page. If a number can't be verified in a source, it's omitted — not invented. Then verification runs as a separate pass. An agent never grades its own homework.

How do you know if it's working?#

Three signals, in order of speed: AI-bot crawl activity in your logs; classic search impressions on the rebuilt pages; and actual citations — your domain appearing as a source in ChatGPT, Perplexity, and AI Overviews answers for your target queries. Check citations manually with real queries; that's the scoreboard that matters.

— Italo Campilii. If you're building something that needs this kind of operator, get in touch.