Listen to this Post
Introduction:
The SEO industry is undergoing a fundamental shift from manual, tool-dependent workflows to autonomous AI agent orchestration. Simon Jackson’s recent LinkedIn post outlining 10 Claude Code loops—each managing an army of 10 sub-agents—represents a paradigm where one prompt on a schedule replaces entire teams of analysts and expensive SaaS subscriptions. This isn’t about AI simply suggesting improvements; it’s about AI agents that take action—crawling, analyzing, rewriting, and validating—while you sleep. The implications for technical SEO, content strategy, and competitive intelligence are profound, with many organizations already deploying these patterns to eliminate execution bottlenecks.
Learning Objectives:
- Understand the architecture of AI agent loops and how Claude Code orchestrates parallel sub-agent workflows
- Master the implementation of ten specific SEO automation loops, from site audits to daily SERP tracking
- Learn to configure Claude Code, MCP servers, and essential command-line tools for production-grade SEO automation
- Gain proficiency in Python scripting, log file analysis, and API integrations for custom SEO tooling
You Should Know:
- The Agentic SEO Stack: Understanding Claude Code, MCP, and Sub-Agent Orchestration
Claude Code is Anthropic’s agentic coding environment that reads codebases, plans sequences of actions, executes them using real development tools, evaluates results, and adjusts its approach. Unlike traditional chatbots that merely provide advice, Claude Code with the right MCP (Model Context Protocol) connections can actually do the work. MCP is an open standard that allows AI assistants to talk to outside tools through one shared interface—meaning a single Claude Code instance can connect to Frase for content research, DataForSEO for SERP data, Google Search Console for performance metrics, and custom Python scripts for log analysis.
The “10 loops” concept leverages Claude’s ability to spawn parallel sub-agents, each handling a discrete slice of work. One loop = one prompt on a schedule. The sub-agents handle the crawling, analysis, and execution. This is made possible through Claude Skills—modular capability packages the agent can auto-invoke, allowing for sequential, conditional, or parallel chaining of tasks.
Setup Guide:
Step 1: Install Claude Code
One terminal command, takes 5 minutes Visit https://claude.com/claude-code for installation claude --version Verify installation
Step 2: Configure Your Project Context
Create a `CLAUDE.md` file in your project root—this is the onboarding document Claude reads before every session:
Site: example.com Niche: [Your industry] Goals: Increase organic traffic by 30% YoY Connected Tools: Search Console, GA4, DataForSEO Writing Style: [Brand voice guidelines]
Step 3: Install Essential MCP Servers and Skills
Install MCP-SEO for comprehensive SEO auditing pip install mcp-seo mcp-seo setup One-time headless browser setup Install DataForSEO Skill for SERP data git clone https://github.com/codykingham/dataforseo-skill.git cd dataforseo-skill && ./install.sh Set API credentials export DATAFORSEO_USERNAME="your-login" export DATAFORSEO_PASSWORD="your-api-password"
Step 4: Create Your First Loop—The Nightly Site Audit
Create a prompt file (e.g., `prompts/nightly-audit.md`):
You are managing 10 sub-agents. Each sub-agent takes one section of the site (e.g., /blog/, /products/, /landing-pages/). For each section: - Crawl all URLs - Hunt broken links (4xx, 5xx) - Identify redirect chains (3+ redirects) - Find orphan pages (no internal links pointing to them) - Generate a full crawl report by 6am Use mcp-seo crawl-site for crawling and mcp-seo links for link analysis. Save output to /reports/audit-YYYY-MM-DD.md
Step 5: Schedule the Loop
Use cron (Linux/macOS) or Task Scheduler (Windows) to trigger Claude Code:
Linux/macOS crontab - runs daily at 5 AM 0 5 cd /path/to/project && claude -p "$(cat prompts/nightly-audit.md)" > logs/audit-$(date +\%Y-\%m-\%d).log 2>&1
2. The Keyword Gap Loop—Mapping Competitor Dominance
This loop deploys sub-agents, each taking one competitor and pulling their ranking pages. The outputs merge into a single list of queries where your site is invisible. This is competitor intelligence at scale, without expensive third-party tools.
Implementation:
Using DataForSEO Skill for competitor keyword data "For each competitor domain in competitors.txt, pull their top 100 ranking keywords" Then: "Compare against our ranking keywords and identify gaps" Python script for gap analysis (scripts/keyword_gap.py) import json import csv from collections import defaultdict def analyze_gap(our_keywords, competitor_keywords): our_set = set(our_keywords) comp_set = set(competitor_keywords) gaps = comp_set - our_set Rank gaps by search volume and difficulty return sorted(gaps, key=lambda x: x['volume'], reverse=True) Run from Claude Code: "python scripts/keyword_gap.py --our data/our_keywords.json --competitors data/competitor_keywords/"
3. The Log-File Loop—Seeing Where Googlebot Actually Goes
Sub-agents split server logs and map where Googlebot actually crawls—and it’s never the pages you think. This is critical for crawl budget optimization.
Linux Command for Log Analysis:
Extract Googlebot requests from Nginx/Apache logs
grep "Googlebot" /var/log/nginx/access.log | \
awk '{print $7}' | \ Extract URL path
sort | uniq -c | sort -rn | head -50 Count and sort by frequency
Python log analyser (scripts/log_analyser.py)
import re
from collections import Counter
def analyse_log(log_path):
bot_pattern = re.compile(r'Googlebot|bingbot|Slurp', re.I)
url_counter = Counter()
with open(log_path, 'r') as f:
for line in f:
if bot_pattern.search(line):
Extract URL (assuming common log format)
parts = line.split()
if len(parts) > 6:
url = parts[bash] Typically the request URI
url_counter[bash] += 1
return url_counter.most_common(100)
if <strong>name</strong> == "<strong>main</strong>":
import sys
results = analyse_log(sys.argv[bash])
for url, count in results:
print(f"{count}: {url}")
Windows PowerShell Equivalent:
Select-String -Path "C:\inetpub\logs\LogFiles.log" -Pattern "Googlebot" |
ForEach-Object { $_ -split ' ' | Select-Object -Index 6 } |
Group-Object | Sort-Object Count -Descending | Select-Object -First 50
4. The Cannibalization Loop—Resolving Keyword Conflicts
One sub-agent per keyword cluster identifies pages competing for the same queries, then recommends which to keep and which to fold in. This resolves the classic SEO problem of multiple pages targeting the same keyword.
Implementation via MCP-SEO:
Crawl site and extract title/h1 tags
mcp-seo crawl-site https://example.com --depth 3 > data/site_structure.json
Python script to detect keyword overlap (scripts/cannibalization_detector.py)
from collections import defaultdict
import json
def detect_cannibalization(pages):
keyword_map = defaultdict(list)
for page in pages:
for keyword in page['target_keywords']:
keyword_map[bash].append(page['url'])
return {k: v for k, v in keyword_map.items() if len(v) > 1}
Claude prompt: "Analyze keyword_map.json and recommend which pages to consolidate"
5. The Rewrite Loop—CTR Optimization at Scale
Sub-agents pull Search Console CTR data page by page, flag underperformers, and draft new titles. This is bulk optimization, not one-by-one editing.
Google Search Console API Integration (Python):
scripts/gsc_performance.py
from google.oauth2 import service_account
from googleapiclient.discovery import build
def get_low_ctr_pages(property_uri, days=28):
credentials = service_account.Credentials.from_service_account_file(
'config/gsc_credentials.json',
scopes=['https://www.googleapis.com/auth/webmasters.readonly']
)
service = build('searchconsole', 'v1', credentials=credentials)
request = {
'startDate': (datetime.now() - timedelta(days=days)).strftime('%Y-%m-%d'),
'endDate': datetime.now().strftime('%Y-%m-%d'),
'dimensions': ['page'],
'rowLimit': 1000
}
response = service.searchanalytics().query(siteUrl=property_uri, body=request).execute()
Filter for pages with CTR < 2% and impressions > 100
low_ctr = [row for row in response.get('rows', [])
if row['ctr'] < 0.02 and row['impressions'] > 100]
return low_ctr
Claude prompt: "For each low-CTR page, generate 3 new title options that improve click-through"
6. The Schema Loop—Structured Data Without Developers
One sub-agent per page type generates and validates structured data. No plugin, no dev ticket—just AI-generated JSON-LD.
Validation Command:
Validate JSON-LD using mcp-seo
mcp-seo structured-data https://example.com/product-page
Or use Google's Rich Results Test via API
curl -X POST "https://searchconsole.googleapis.com/v1/urlTestingTools/mobileFriendlyTest:run?key=YOUR_API_KEY" \
-H "Content-Type: application/json" \
-d '{"url": "https://example.com/product-page"}'
Claude Prompt for Schema Generation:
You are a schema.org specialist. For each page type in the sitemap: - Product pages: generate Product, Offer, AggregateRating schema - Blog posts: generate , BlogPosting, Person (author) schema - FAQ pages: generate FAQPage, Question, Answer schema Output as JSON-LD and validate using mcp-seo structured-data
7. The Internal-Link Loop—The Cheapest Ranking Win
Sub-agents map every link on the site and surface money pages with zero internal links pointing at them. This is often the lowest-effort, highest-impact SEO action available.
Implementation:
Crawl and extract internal links mcp-seo links https://example.com --internal-only > data/internal_links.json Python script to identify orphan pages (scripts/orphan_finder.py) import json def find_orphans(all_urls, linked_urls): all_set = set(all_urls) linked_set = set(linked_urls) return all_set - linked_set Then: "For each orphan page, suggest 3 internal linking opportunities from high-authority pages"
8. The Core Web Vitals Loop—Performance Monitoring
Watches every deploy and flags LCP (Largest Contentful Paint) regressions the same day they ship.
Linux/macOS Command for Vitals Monitoring:
Using Lighthouse CLI npm install -g lighthouse lighthouse https://example.com --only-categories=performance --output=json > reports/lighthouse_$(date +%Y-%m-%d).json Extract LCP, FID, CLS cat reports/lighthouse_$(date +%Y-%m-%d).json | jq '.categories.performance.score, .audits["largest-contentful-paint"].displayValue'
CI/CD Integration (GitHub Actions):
.github/workflows/cwv-check.yml
name: Core Web Vitals Check
on:
deployment_status:
branches: [bash]
jobs:
check-vitals:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- name: Run Lighthouse
run: |
npx lighthouse ${{ github.event.deployment_status.target_url }} --output=json --output-path=report.json
- name: Check LCP Regression
run: |
LCP=$(jq '.audits["largest-contentful-paint"].numericValue' report.json)
if (( $(echo "$LCP > 2500" | bc -l) )); then
echo "LCP regression detected: $LCP ms"
exit 1
fi
9. The Content Decay Loop—Reviving Slipping Pages
Each sub-agent adopts a slipping page and rewrites it against what outranks it. This is content refresh at scale.
Implementation:
scripts/decay_analyzer.py
import requests
from bs4 import BeautifulSoup
def analyze_competitor_content(url):
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
Extract word count, headings, internal links, schema
return {
'word_count': len(soup.get_text().split()),
'headings': [h.get_text() for h in soup.find_all(['h1', 'h2', 'h3'])],
'internal_links': len(soup.find_all('a', href=True))
}
Claude prompt: "For each decaying page, compare against top 3 competitors.
Generate a rewrite plan that closes content gaps while maintaining brand voice."
- The Daily SERP Loop—Rankings Without the $99/mo Tool
Positions pulled into a sheet every morning. This replaces expensive rank-tracking subscriptions.
Implementation with DataForSEO:
DataForSEO Skill for daily SERP pulls
"For each target keyword in keywords.txt, pull Google organic SERP positions for our domain"
Output to: reports/serp-$(date +%Y-%m-%d).csv
Simple curl-based rank checker (Linux)
for keyword in "keyword1" "keyword2" "keyword3"; do
curl -s "https://api.dataforseo.com/v3/serp/google/organic/live" \
-H "Authorization: Basic $(echo -1 $DATAFORSEO_USERNAME:$DATAFORSEO_PASSWORD | base64)" \
-d "{\"target\": \"example.com\", \"keyword\": \"$keyword\"}"
done
What Simon Jackson Says:
- “None of this is hard—most SEOs just never script it.” The barrier isn’t technical complexity; it’s the willingness to move from point-and-click tools to prompt-based automation.
- “Setup is one prompt per loop. Then they run without you.” Once configured, these loops operate autonomously, delivering insights before you start your day.
Analysis: The implication of Jackson’s framework is that SEO is transitioning from a knowledge-based discipline to an engineering discipline. The value proposition shifts from knowing what to do to building systems that do it automatically. This mirrors the broader trend in cybersecurity and IT, where SOAR (Security Orchestration, Automation, and Response) platforms have replaced manual incident response. The 10 loops represent a similar SOAR-like capability for SEO—continuous monitoring, automated analysis, and scheduled remediation. Organizations that adopt these patterns gain a compounding advantage: while competitors spend hours on manual audits, agentic loops deliver fresh intelligence daily, enabling faster iteration and more aggressive optimization. The $99/mo tools being replaced aren’t just a cost saving—they’re a capability upgrade, because these loops are customizable and extensible in ways off-the-shelf tools never can be.
Prediction:
- +1 The democratization of AI agent orchestration will lower the barrier to enterprise-grade SEO, enabling SMBs to compete with larger players through automation rather than headcount.
- +1 The integration of Claude Code loops with CI/CD pipelines will make SEO a real-time concern, not a quarterly audit—performance regressions caught and fixed within hours.
- -1 The reliance on AI-generated content and automated rewrites risks creating a homogenized web, where pages optimized for algorithms lose distinctiveness and brand voice.
- -1 Organizations that fail to implement these patterns will face widening competitive gaps as rivals compound daily gains from automated optimization.
- +1 The shift from tool subscriptions to prompt-based automation will accelerate the development of open-source SEO tooling, reducing vendor lock-in and increasing transparency.
- +1 MCP’s standardization will enable a new ecosystem of interchangeable SEO agents, where specialized tools (crawling, SERP analysis, schema validation) can be mixed and matched like Lego bricks.
- -1 Security risks will emerge as API keys and sensitive data become embedded in prompt chains—organizations will need robust secret management and audit trails.
- +1 The 10-loop pattern will expand beyond SEO into adjacent domains: content marketing, social media management, paid search optimization, and eventually full-stack marketing automation.
- -1 The “set and forget” nature of these loops may lead to complacency, with critical errors going unnoticed without human oversight and quality gates.
- +1 SEO professionals who embrace agentic workflows will evolve from “doers” to “architects”—designing, monitoring, and refining autonomous systems rather than executing repetitive tasks.
▶️ Related Video (70% Match):
🎯Let’s Practice For Free:
🎓 Live Courses & Certifications:
Join Undercode Academy for Verified Certifications
🚀 Request a Custom Project:
Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
[email protected]
💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands
IT/Security Reporter URL:
Reported By: Simon Jackson – Hackers Feeds
Extra Hub: Undercode MoN
Basic Verification: Pass ✅
