In 2026 I moved my entire SEO operation onto Claude Code. Not “I use AI for outlines” or “I paste drafts into a chatbot.” I mean the terminal agent now executes the work: it audits sites, writes and publishes posts over the WordPress REST API, rewrites titles from Search Console exports, ships schema, and fixes Core Web Vitals. I have been doing SEO since 2016. Today I operate more than 20 WordPress sites this way, and five of them were designed end to end with Claude Code. This post is the honest, complete answer to the question I keep getting: what does Claude Code SEO actually look like in practice?
What “Claude Code SEO” actually means
Claude Code is Anthropic’s command line agent. You type what you want in plain language, and instead of answering with a wall of text, it acts: it lists your files, fetches your pages, runs commands, edits code, and checks the result. For SEO, that changes the unit of work.
With a chatbot, the unit of work is a draft. You ask for a meta description, you get text, and then you do the actual job: log in, paste, save, purge cache, check the live page. With Claude Code, the unit of work is the finished change. You say “rewrite the title and meta description on the pricing post to match the queries it already ranks for, then push it live and show me the live HTML,” and it does all of that, including the verification at the end.
Three properties make this work for SEO specifically:
- It can read your actual site. Not your description of your site. It fetches the rendered HTML, sees what the theme injected, notices the duplicate H1 your page builder added, and finds the redirect chain you forgot about.
- It can write to your actual site. Through the WordPress REST API, it creates and updates posts, sets featured images, and edits metadata. No browser, no copy-paste step where errors creep in.
- It can verify. After every change it can fetch the live URL and confirm the change is really there. A surprising amount of SEO work fails silently. An agent that checks its own output catches that.
If you want the concrete prompt-level version of this, I published the exact prompts I use in the Claude Code technical SEO playbook. This post is the layer above it: the system those prompts run inside.
The setup: WordPress + Claude Code in 20 minutes
Everything in this post runs on one boring, stable foundation: the standard WordPress REST API plus an application password. No custom plugin required, no agency software, nothing exotic.
Step 1: Create an application password
In wp-admin, go to Users, open your profile, scroll to Application Passwords, name one (I use “claude-code”), and copy the generated password. This is a separate credential from your login. It can be revoked any time without touching your real password, which is exactly what you want for agent access.
Step 2: Verify the API answers
From a terminal, one request proves the whole pipeline:
Invoke-RestMethod -Uri "https://yoursite.com/wp-json/wp/v2/posts?per_page=1" |
Select-Object id, slug, statusIf that returns a post, Claude Code can read your site. Authenticated writes use the same endpoint with your username and the application password as Basic auth. Claude Code writes these calls itself; you never have to memorize the API.
Step 3: Tell Claude Code about the site once
Claude Code reads a project memory file (CLAUDE.md) at the start of every session. Mine contains the site URL, the auth pattern, the content conventions (heading style, internal link targets, schema rules), and the traps specific to that site. Write it once and every future session starts already knowing your stack. This single file is the difference between an agent that needs babysitting and one that ships.
That is the whole setup. The first time I did this it felt too thin to be real. It is not. The standard REST API covers posts, pages, media, categories, and metadata, which covers most of what SEO execution actually is.
The five jobs I hand Claude Code every week
1. Technical audits
Crawl the key templates, fetch rendered HTML, check title and H1 and canonical and robots and schema and internal links, and produce a ranked list of what is broken. This used to be a $2,000 deliverable with a two week turnaround. The mechanical 80% of it now takes an afternoon. My 23-point technical checklist is the spec I audit against; Claude Code is what executes it.
2. Content publishing pipelines
This is the biggest one. A post on my sites is not text in a box. It is a designed document: styled sections, comparison tables, FAQ blocks, schema, internal links, a featured image, and metadata. Claude Code builds the full HTML, pushes it over REST, sets the featured image, and verifies the live render. The post you are reading right now went live through exactly this pipeline.
3. CTR rewrites from Search Console data
Export queries and pages from GSC, hand the CSV to Claude Code, and ask the only question that matters: where do impressions massively outrun clicks, and what should those titles say instead? Then it ships the rewrites through the API. This is the highest ROI work in SEO right now because it monetizes rankings you already have. No new content, no links, just intent matching at scale.
4. Schema generation and validation
Claude Code generates JSON-LD from the actual page content, which means the schema describes what is really on the page instead of what a generic template assumes. It validates before shipping and avoids the duplicate-schema mess that plugins create. The patterns I use are documented in the schema field guide.
5. Performance and Core Web Vitals fixes
Image conversion to WebP and AVIF, font loading fixes, layout shift hunting, cache configuration. Claude Code reads the PageSpeed output, maps each flag to a concrete fix in the actual theme or content, and ships them one at a time. Performance work is tedious precisely because it is many small mechanical fixes. That is the exact shape of work an agent is good at.
A real publish, end to end
Here is what shipping one post actually looks like, so you can see where the human sits in the loop.
- I decide the target. Which query, which intent, what angle, what is true and provable. This is judgment. The agent does not pick targets.
- Claude Code drafts in my voice, against my rules. The CLAUDE.md conventions enforce structure: key takeaways up top, tables where comparison happens, no fabricated numbers, internal links to the posts that earn them.
- It builds the designed HTML. Styled sections, the FAQ block, the schema, the byline. One self-contained document.
- It pushes over REST and sets metadata. Title tag, meta description, featured image, category, slug. One API call each, all scripted, nothing clicked.
- It verifies live. Fetch the published URL, confirm the markup survived WordPress, confirm the schema validates, confirm the title rendered once and only once.
- I review the live page. Last look before it counts: claims, links, design. If something is off, I say so in one line and the agent fixes and re-verifies.
Total elapsed time for a deep, designed post: a morning. The same post done by hand, with the same design standard, used to take me two to three days. The quality did not drop. The iteration count went up, because revisions are cheap when the execution layer is instant.
The traps that cost me hours, mapped
Everything above sounds clean. Production is not clean. WordPress is twenty years of compatibility decisions, and several of them silently destroy agent-written markup. These are the ones that actually bit me, and what prevents each one.
| Trap | What happens | The fix |
|---|---|---|
| Auto-formatting on save | WordPress wraps raw markup in paragraph tags on render and breaks embedded styling | Structure the document so WordPress treats it as raw HTML, then verify the rendered output, not the saved input |
| Attribute stripping | Custom data attributes are silently removed when content is saved over the API | Keep state in visible text or rework the pattern; never trust attributes to survive |
| Smart-quote texturizing | WordPress converts characters inside inline code into typographic entities, which can break embedded logic | Avoid fragile character pairs in inline code and validate the live page after every push |
| Theme markup injection | The theme prints its own H1 and title outside your content, so the saved content looks fine while the live page has duplicates | Audit the rendered HTML, never the editor view; disable theme titles where needed |
| Caches lying | The page cache or a CDN serves the old version after a successful update, so a correct change looks like a failure | Always re-check with a cache-busting query string before concluding anything failed |
| Stale CSS bundles | Optimization plugins keep serving the previous stylesheet after a design change | Purge the CSS cache as a standard step in every deploy, not as a debugging discovery |
Two things to notice. First, none of these are model failures. Claude Code wrote correct markup every time; WordPress changed it after the fact. Second, every one of them is invisible unless you verify the live page. This is why “fetch the live URL and confirm” is a non-negotiable final step in every workflow I run. I keep a running trap map for my own operation, and it is the single most valuable document I own, because each entry converts a repeated multi-hour debugging session into a known one-line rule.
What Claude Code is bad at
An honest tools post needs this section, and most of them skip it.
- Strategy. It will not tell you which market to enter, which query deserves a page, or whether your site should exist. If you cannot rank sites without an agent, the agent gives you faster execution of bad decisions.
- Facts it cannot verify. Left unsupervised, any model will fill gaps confidently. My rules file bans invented statistics and unverifiable claims, and I still review every claim before publish. The discipline is mine, not the model’s.
- Taste. It proposes; it does not know your brand. Design and voice converge only because I correct it and the corrections persist in the project memory file.
- Anything behind a login it does not have. No API access means no agent access. The setup section above is short, but it is mandatory.
Claude Code vs ChatGPT for SEO work
| Dimension | Chat assistants | Claude Code |
|---|---|---|
| Output | Text you copy somewhere | Changes shipped to the live site |
| Context | What you paste into the window | Your real files, real pages, real API responses |
| Verification | None; you check manually | Fetches the live result and confirms |
| Repeatability | Re-explain every session | Project memory file persists conventions and traps |
| Scale | One artifact at a time | Loops: 50 title rewrites, 100 image conversions, full-site audits |
| Best at | Brainstorming, one-off drafts | Execution pipelines on sites you control |
I still use chat interfaces for ideation. But the moment work touches a real site, the terminal wins, because SEO work that is not live does not exist.
How to start this afternoon
- Pick one site you control. Not your biggest client. A site where a mistake costs you nothing but a redo.
- Create the application password and confirm the REST API answers with the one-line check above.
- Start with a read-only job. Ask Claude Code to audit ten pages against a checklist and rank what it finds. Read-only work builds trust before you grant write access in your head.
- Ship one small write. A meta description on one post. Verify it live, with the cache busted. Feel the loop close.
- Write the memory file. Every convention you correct, every trap you hit, goes in. This file compounds. After a month it is the most valuable SEO asset you own.
- Then scale to a pipeline. The GSC CTR rewrite is the best first pipeline: highest ROI, lowest risk, entirely reversible.
If you would rather not spend the weeks reconstructing the pipelines and the trap map from scratch, that is exactly what the Claude Code SEO Operator Kit is: my four production playbooks, the working publishing and audit tooling, the prompt set, and every trap in this post plus eighteen more, already documented. It is the system this site, and the posts on it, ship through.
Where this goes next
The reason I committed my whole operation to this in 2026 is not the time savings, although they are real. It is that search itself is splitting. Rankings still matter, but citations inside ChatGPT, Perplexity, and Google’s AI Overviews are becoming a parallel distribution channel, and earning them is execution-heavy work: structured content, aggressive schema coverage, fast clean pages, constant iteration. I covered the citation side in the AI citations playbook.
An operator with an execution agent can run that iteration loop at a tempo a manual workflow cannot touch. That is the actual story of Claude Code SEO. Not magic, not replacement, just the execution layer of a real SEO practice moved into a terminal, verified on every push, and compounding through a memory file that never forgets a lesson.
One operator, one terminal, twenty-plus live sites. It works. Set up the application password and find out on your own site this afternoon.
