Everyone's writing think pieces about how AI "could" revolutionize SEO.
We built the actual system.
For the past two months, we've been running a fully automated SEO engine for a B2B SaaS client. Not manually prompting Claude for blog ideas. Not using ChatGPT to rewrite meta descriptions.
A production pipeline that connects keyword research, content generation, publishing, performance monitoring, and optimization in one continuous loop.
The results aren't hypothetical:
One new page hit position 5 in Google within 7 days
Overall organic impressions 3x'd in under two weeks
Click-through rates jumped across the board once we started data-driven title optimization
The client got their first midnight Slack notification about an impression spike
This is the actual stack, the real workflow, and the honest breakdowns of what worked and what didn't.
The Problem: SEO Tools Don't Talk to Each Other
Here's what SEO looked like before we automated it:
Monday: Pull keyword data from Ahrefs. Export to CSV. Analyze in spreadsheets.
Tuesday: Check Google Search Console for underperforming pages. Export more CSVs. Cross-reference with the Ahrefs data. Flag pages with high impressions but low CTR.
Wednesday: Write content briefs for the content team. Wait for drafts to come back (if you have a content team). Or write them yourself (if you don't).
Thursday: Edit drafts. Add internal links manually. Generate meta descriptions. Upload to CMS.
Friday: Publish. Submit to Google for indexing. Wait.
Next Monday: Check if anything worked. Probably didn't. Start over.
Every step required exporting, importing, copying, pasting, and context-switching between tools.
The tools themselves are amazing. Ahrefs gives you keyword intelligence. Google Search Console shows you actual performance. Sanity CMS makes content management clean.
But they don't talk to each other.
The bottleneck was never the tools. It was the manual workflow connecting them.
The Stack: How We Connected Everything
Here's the complete technical stack and what each piece actually does:
Claude Code: The Strategic Engine
Claude Code isn't ChatGPT in a terminal. It's an agentic AI environment that can read files, write code, call APIs, and execute multi-step workflows autonomously.
We're using it as the brain that connects every other tool in the stack.
What Claude handles:
Content Generation with Persistent Context
We don't do one-off prompts. We set up a project structure where Claude has persistent access to:
Brand voice guidelines (stored in CLAUDE.md)
Target audience profiles (ICP definitions)
Historical content performance data
Internal linking structure
Preferred content formats
When Claude writes a blog post, it's not generic AI content. It knows who we're writing for, how we write, what's worked before, and what internal pages to link to.
Google Search Console Analysis
We connected Claude to GSC via the Google Search Console API.
Every week, Claude automatically pulls:
Pages with high impressions but low click-through rates
Queries where we're ranking on page 2 (positions 11-20)
Pages that lost traffic in the last 30 days
Competitor pages outranking us for target keywords
Then it generates a prioritized action plan: which titles to rewrite, which pages need content expansion, which internal links are missing.
Meta Title Optimization (The 49x CTR Win)
This is where we found gold.
Claude identified a page getting 15,000+ US impressions per month at 0.31% CTR.
Same exact page in India? 15.31% CTR.
The content was identical. The URL was identical. The only difference was the meta title optimized for Indian search behavior.
Claude analyzed the high-performing Indian title, identified the elements that worked (specific benefit callouts, urgency language), and rewrote the US title to match that structure.
New US CTR after rewrite: 15.2%.
That's a 49x improvement in click-through rate. Same content. Better title.
We would have never caught this manually. The pattern only emerged when Claude cross-referenced GSC data by geo, which nobody does because it's tedious.
Internal Linking Automation
One of Claude's ongoing tasks is maintaining our internal link structure.
Every time we publish a new page, Claude:
Reads the content
Identifies related existing pages
Suggests where to add links from old content to new content
Writes the exact anchor text to use
Generates a prioritized list of pages to update
Then it goes one step further: it actually writes the code changes to add those links, commits them to our repository, and creates a pull request for review.
Human approval is still required. But the tedious "find all pages that should link here" work is automated.
Ahrefs: The Intelligence Layer
Ahrefs tells us what to write about.
We're using the Ahrefs API through an MCP (Model Context Protocol) server that Claude Code can query directly.
What we pull from Ahrefs:
Keyword Difficulty (KD): We filter for KD under 30 for new content, under 50 for established pages
Search Volume: Minimum 500 monthly searches in the US
Competitor Content Gaps: Pages our competitors rank for that we don't
SERP Analysis: What's currently ranking for our target keywords
Claude doesn't just pull this data. It interprets it.
Example query: "Find keywords with 1,000+ monthly volume, KD under 25, that our top 3 competitors rank for but we don't. Prioritize by estimated traffic value."
Ahrefs returns the data. Claude filters, scores, and generates a ranked list of content opportunities.
No spreadsheets. No manual analysis. Just actionable priorities.
Sanity CMS: The Publishing Pipeline
Sanity is our headless CMS. Every piece of content lives here as structured data.
We connected Sanity to Claude via its Content API.
The automated publishing workflow:
Claude generates a content draft (markdown format)
Claude converts markdown to Sanity's portable text format
Claude creates a new document in Sanity via API
Claude sets the appropriate tags, categories, and metadata
Claude generates a slug (URL) based on target keyword
Claude uploads any referenced images to Sanity's asset pipeline
Document sits in "Draft" status for human review
Human approves → status changes to "Published"
Webhook triggers → static site regenerates → new page goes live
Claude submits URL to Google via IndexNow
The entire flow from "write content" to "live on the internet and indexed in Google" takes about 4 minutes after human approval.
Zero copy-pasting. Zero manual uploads. Zero forgetting to submit for indexing.
Google Search Console: The Feedback Loop
GSC is where we measure what's actually working.
We set up a weekly automated analysis that pulls:
High Impression, Low CTR Pages
These are the low-hanging fruit. You're already ranking. People are seeing your result in search. They're just not clicking.
Usually, the problem is:
Boring meta title
Weak value proposition
Missing urgency or benefit
Too generic compared to competitors
Claude identifies these pages, analyzes the top 3 ranking competitors' titles, and generates rewrite suggestions.
Queries We Rank For (But Don't Have Content For)
Sometimes you rank accidentally. GSC shows queries you're getting impressions for that you never targeted.
Claude flags these and checks: "Do we have a page specifically targeting this query? If not, should we?"
Often, the answer is yes. These become priority content opportunities because Google has already signaled that our domain is relevant.
Position 11-20 Pages (Page 2 Rankings)
These are almost wins. You're close to page 1 but not there yet.
Small improvements can push these over. Claude identifies them and recommends:
Content expansion (add 500+ words of depth)
Better internal linking from high-authority pages
Schema markup additions
Title/description rewrites
Then it drafts the actual changes and creates pull requests.
Perplexity: The Market Research Engine
Perplexity is our "what are people actually asking?" tool.
We use it to understand:
Buyer questions at each stage (awareness, consideration, decision)
Competitor positioning (how they're framing the problem)
Market language (what terms real people use, not just SEO keywords)
Example workflow:
Claude queries Perplexity: "What questions are B2B SaaS buyers asking about [our product category]?"
Perplexity returns real questions from Reddit, Quora, industry forums, and Q&A sites.
Claude analyzes these questions, clusters them by theme, and identifies which ones we haven't answered yet.
Those become content briefs: "Write a blog post answering: [specific buyer question]."
This ensures every piece of content we publish is answering real queries, not just chasing keyword volume.
What This Stack Doesn't Replace (And Why That's Important)
Here's the honest truth: automation isn't magic.
There are things this system absolutely does not replace, and trying to automate them would be a mistake.
Strategic Decisions
Claude can tell you which keywords have high volume and low difficulty.
It can't tell you which ones align with your business goals.
If we're a B2B SaaS selling to enterprise clients, ranking for "free alternatives to [competitor]" might drive traffic but zero revenue.
A human still decides:
Which keywords we target (based on ICP fit, not just volume)
What angle we take on a topic
Which content formats we prioritize (guides vs. comparisons vs. case studies)
Quality Review
Every piece of content sits in "Draft" status until a human approves it.
We don't auto-publish anything.
Why? Because LLMs hallucinate. Not often, but it happens.
Claude might confidently state a statistic that's wrong. Or misinterpret a data point. Or use phrasing that doesn't match our brand voice.
Human review catches this. Every time.
The "Client Freakout" Prevention
Automation handles consistency. Humans handle exceptions.
When a client messages at 11 PM saying "our homepage isn't ranking anymore," that's not an automation problem. That's a strategic problem that requires context, judgment, and probably a phone call.
The system handles everything that should be systematized. Humans handle everything that shouldn't.
The Results: What Actually Happened
Two months into running this system for our B2B SaaS client, here's what changed:
Week 1-2 (Setup Phase)
Connected all APIs
Built the Claude Code workflows
Set up the Sanity publishing pipeline
Created the first batch of content (5 blog posts)
Week 3-4 (First Results)
3 posts published and indexed
One hit position 5 within 7 days (KD 18 keyword, 1,200 monthly volume)
Overall impressions started climbing (+40% week-over-week)
Week 5-6 (Optimization Kicks In)
GSC analysis identified 12 underperforming pages
Rewrote meta titles for all 12
Average CTR improved from 2.1% to 4.8%
Impressions jumped another 80%
Week 7-8 (Compounding Effects)
Internal linking automation strengthened site structure
Older content started ranking for long-tail variations
Total organic impressions 3x'd compared to baseline
Client got their first notification about traffic spiking
The Midnight Emoji
The best validation wasn't a graph. It was the client's Slack message at 12:47 AM:
"😳 are you seeing this traffic spike??"
That's the moment you know automation is working. When the results are so obvious that the client notices without being told.
The Technical Breakdown: How It Actually Works
If you want to build this yourself, here's the real implementation:
Step 1: Set Up the MCP Servers
MCP (Model Context Protocol) is how Claude Code connects to external tools.
We're using these MCP servers:
Ahrefs MCP Server (@ahrefs/mcp)
Keyword research queries
Competitor gap analysis
SERP data pulls
Google Search Console MCP Server (community-built)
Performance data exports
Query and page analysis
Indexing status checks
Sanity CMS Custom MCP (we built this)
Content creation via API
Document updates
Asset uploads
Each server runs as a background process. Claude Code connects to them via stdio or HTTP.
Installation example:
# Install Ahrefs MCP server
npm install -g @ahrefs/mcp
# Start the server
ahrefs-mcp --api-key YOUR_KEY
# Claude Code automatically discovers it
Step 2: Create the CLAUDE.md Context File
This is critical. Without this, Claude generates generic content.
Our CLAUDE.md includes:
# Brand Voice Guidelines
## Tone
- Conversational but authoritative
- No corporate jargon
- Use "we" and "you", not "one" or "users"
- Contractions are fine
## Prohibited Phrases
- "In today's digital landscape"
- "Leverage" (use "use" instead)
- "Synergy"
- "Thought leader"
## Content Structure
- Hook in first 2 sentences
- No walls of text (max 3 sentences per paragraph)
- Subheads every 200-300 words
- Lists and bullets for scannability
## ICP (Ideal Customer Profile)
- B2B SaaS founders (revenue $100K-$5M)
- Technical but time-constrained
- Solving [specific problem]
- Prefers tools that "just work" over customization
Claude reads this file before generating any content. It's the difference between AI slop and content that sounds like your brand.
Step 3: Build the Automated Workflows
We created several workflow scripts that Claude Code executes:
Weekly GSC Analysis:
claude /analyze-gsc
This triggers a script that:
Pulls last 28 days of GSC data
Identifies pages with impression/CTR imbalance
Compares to previous 28-day period
Flags pages that lost traffic
Generates a prioritized action report
Content Creation Pipeline:
claude /create-content --keyword "target keyword here"
This triggers:
Ahrefs query for keyword data and SERP analysis
Perplexity query for buyer questions
Content brief generation
Full blog post draft
Sanity CMS document creation (draft status)
Slack notification for human review
Internal Linking Update:
claude /update-internal-links --new-page "/blog/new-post"
This triggers:
Reads the new page content
Searches existing content for relevant mentions
Identifies linking opportunities
Generates anchor text suggestions
Creates pull request with proposed changes
Step 4: Human Review Gates
We have three mandatory human review points:
Content approval: Human approves draft before it goes live
Title changes: Human reviews meta title rewrites before deployment
Link additions: Human approves pull requests before merging
These gates prevent the system from making mistakes that would be hard to undo.
Step 5: Monitor and Iterate
Every Friday, we review:
What published this week
What's ranking
What's not working
Where Claude made mistakes
Then we update CLAUDE.md with new guidelines based on what we learned.
The system gets smarter every week because the context file evolves.
The Mistakes We Made (So You Don't Have To)
Building this wasn't smooth. Here's what went wrong:
Mistake 1: Trusting Claude's Numbers Without Verification
Early on, Claude reported that a page had "2,400 monthly impressions."
We celebrated. Then we checked GSC manually.
Actual number: 240.
Claude hallucinated an extra zero.
The fix: We now have a verification step where a second Claude instance (using a different model) checks the first one's math. If they disagree, a human investigates.
Mistake 2: Over-Optimizing Meta Titles
We let Claude rewrite 40 meta titles in one day.
Rankings tanked the next week.
Why? Google saw massive title changes across the site and interpreted it as manipulation.
The fix: We now limit title changes to 5 per week. Gradual optimization doesn't trigger red flags.
Mistake 3: Ignoring Brand Safety
Claude generated a blog post comparing our product to a competitor.
The tone was... aggressive. It read like we were attacking them.
That's not our brand. But Claude didn't know that because we hadn't specified it in CLAUDE.md.
The fix: Added explicit "what not to say" guidelines. Now Claude knows:
No direct competitor attacks
No claiming we're "the best" at anything
No fearmongering ("if you don't use this, you'll fail")
Mistake 4: Auto-Publishing Everything
For about 3 days, we experimented with fully automated publishing. Claude wrote content, published it, and submitted it to Google without human review.
We caught this before it became a disaster, but one post went live with a factual error in the opening paragraph.
The fix: Mandatory human approval. Always. No exceptions.
The ROI: Was It Worth Building?
Building this system took about 40 hours of initial setup:
10 hours connecting APIs and setting up MCP servers
15 hours writing the automation workflows
10 hours creating CLAUDE.md and brand guidelines
5 hours testing and debugging
Time savings per week: ~20 hours
Before automation:
8 hours doing keyword research and GSC analysis
6 hours writing content briefs
4 hours managing the CMS and publishing
2 hours tracking performance
After automation:
2 hours reviewing Claude's work
1 hour approving content and PRs
30 minutes checking results
Break-even point: 2 weeks
Ongoing value: 15-20 hours saved every week
But the real ROI isn't time saved. It's results that wouldn't have happened manually.
The 15K impressions / 0.31% CTR page? We would have never found that pattern by hand.
The position 5 ranking in 7 days? That came from targeting a keyword opportunity Claude identified that we would have missed.
The 3x impression growth? That's compounding velocity. Claude ships faster than humans, which means more content, which means more rankings, which means more traffic.
Automation doesn't just make you faster. It makes you see opportunities you couldn't see before.
What Comes Next: Where This Is Heading
We're currently at about 60% automation.
The remaining 40% is strategic work that should stay human:
Deciding which products to build content around
Choosing market positioning angles
Creating truly original insights (not just SEO content)
Handling client communication
But there are things we're exploring for the next iteration:
1. Automated Competitor Monitoring
Set up a weekly process where Claude:
Checks competitors' blogs for new content
Analyzes which keywords they're targeting
Identifies if they're ranking for anything we should target
Generates counter-content briefs
2. Programmatic SEO for Long-Tail Keywords
For highly structured content (comparison pages, alternative pages, tool directories), we're testing if Claude can generate hundreds of pages from templates without quality loss.
3. Video Content Integration
YouTube is becoming a search engine. We're exploring if Claude can:
Generate video scripts from blog posts
Create optimized titles and descriptions
Suggest thumbnail concepts
4. AI Overview Optimization (GEO)
Google's AI Overviews are changing search. We're testing if we can optimize content specifically to appear in AI-generated answers.
Early tests show that structured data (schema markup) and clear, quotable answers increase citation likelihood.
The Bottom Line: Automation as a Moat
Here's the uncomfortable truth about SEO in 2026:
Everyone has access to the same tools. Ahrefs, Semrush, GSC, ChatGPT, Claude — they're all available to anyone willing to pay.
Tool access isn't a competitive advantage anymore.
Process is the moat.
The companies winning at SEO aren't the ones with the best tools. They're the ones who connected their tools into a system that compounds faster than competitors can keep up.
We went from publishing 2 blog posts per month to publishing 12.
We went from finding CTR problems once a quarter to finding them every week.
We went from hoping Google would index our content eventually to submitting it for indexing within 4 minutes of publishing.
Our competitors have the same tools. But they're still doing everything manually.
By the time they write one blog post, we've written six, optimized eight old ones, and identified twelve new opportunities.
That's not a small edge. That's a compounding advantage that grows every week.
How to Get Started (Without Building Everything)
You don't need to replicate our entire stack to see results.
Here's the minimum viable version:
Week 1: Set Up Claude Code + GSC
Connect Claude to your Google Search Console data. Ask it to find high-impression, low-CTR pages. Rewrite those titles first.
This alone could 2-3x your traffic from existing content.
Week 2: Add Keyword Research
Use Ahrefs or Semrush data. Ask Claude to identify content gaps. Write briefs for the top 5 opportunities.
Week 3: Automate Publishing
Connect your CMS via API (WordPress, Sanity, Contentful all have APIs). Let Claude publish drafts that you review.
Week 4: Build Internal Linking
Let Claude analyze your content and suggest where internal links should be added. Implement its recommendations.
That's it. Four weeks to a basic automated SEO system.
Then you iterate. Add more data sources. Automate more steps. Build feedback loops.
Six months from now, you'll have a system that compounds faster than competitors can match.
