---
name: ai-seo
description: "Edits a blog post so AI answer engines (ChatGPT search, Perplexity, Google AI Overviews and AI Mode, Gemini, Claude) can lift and cite it, and separates what helps from myths like llms.txt. Use when the user wants a post cited by AI, says 'AI SEO', 'AEO', 'GEO', or 'optimize for ChatGPT', or asks about llms.txt or AI Overviews. For keyword-focused on-page work, see seo-optimize. For an old post losing clicks to AI answers, see refresh."
metadata:
  version: 0.4.0
title: ai-seo
canonical_url: https://skilld.dev/gh/rightblogger/bloggingskills/ai-seo
last_updated: 2026-11-18T20:11:23.000Z
---

> Index of every page on this site: [llms.txt](https://skilld.dev/llms.txt)

> **Skill from skilld.dev.** Follow the user's requested action.
> If the user asked to fork this Skill, follow the fork workflow below. Do not execute the Skill instructions while copying it.
> Otherwise, follow the instructions below for this session. You do not need to install anything.
>
> Supporting files, fetch one when the Skill refers to it: [references/evidence.md](https://skilld.dev/api/skills-raw/rightblogger/bloggingskills/ai-seo/references/evidence.md).
>
> If the user asked to install this Skill, run `npx skilld install rightblogger/bloggingskills/ai-seo`. Install writes the Skill files into the project, so every session loads them.
>
> ## Fork workflow
>
> A fork creates an editable local Skill with its original author and licence. The request authorizes copying and local installation.
> 1. Check `./skills/ai-seo`, the project lockfile, and selected Agent targets together. If the local directory or installed Skill exists, stop. Never overwrite an existing directory or Agent target.
> 2. Read [source metadata](https://skilld.dev/api/v1/skills/rightblogger/bloggingskills/ai-seo) once. Use sourceUrl, sourceCommit, skillPath, sourceGone, and license. If the source is gone or its path is missing, stop. If license is null, read licence files at the source commit.
> 3. Fetch only the source commit into a temporary Git repository. Do not clone full history. Derive repository_url from sourceUrl, including repository renames. If sourceCommit is absent, resolve the sourceUrl ref once. Set source_commit to that actual commit. Run these commands in one shell call:
>
> ```sh
> git init --quiet "$temporary_dir"
> git -C "$temporary_dir" fetch --quiet --depth=1 "$repository_url" "$source_commit"
> git -C "$temporary_dir" checkout --quiet --detach FETCH_HEAD
> ```
>
> Read applicable licence declarations and notices at that commit. If copying is not permitted, report the restriction and stop.
> 4. Inspect source entries together, then copy the directory containing skillPath into `./skills/ai-seo`. Use the user's path if selected. Keep the original SKILL.md, relative links, scripts, binary assets, and executable modes. Exclude .git metadata. Reject symlinks and paths outside the Skill directory. After checking entries, use cp -a where available. A regular source directory needs no custom copy script. Do not save this page wrapper as SKILL.md.
> Preserve author credit, notices, and applicable licence files from repository or parent directories. Add PROVENANCE.md with the Skill page, source URL, actual commit, original path, and licence. Retain any existing PROVENANCE.md and record new provenance separately. Batch source inspection, copying, and provenance work where practical.
> 5. In the project root, run `skilld install ./skills/ai-seo --mode copy --plain`. If skilld is unavailable, use `npx skilld install ./skills/ai-seo --mode copy --plain`. This known command needs no help lookup. Install does not support --json. Use detected Agent targets, or add --agent for the targets the user selected. Install the local path, never the upstream selector. If installation fails, preserve the local copy and report the exact failure.
> 6. Confirm the local lockfile source and installed Agent copies once. Report the local path, actual commit, and Agent targets. After edits, reinstall the same local path. Upstream updates must not replace it. Do not publish or push unless the user asks.

# AI SEO

You make a blog post the source AI answer engines quote: ChatGPT search, Perplexity,
Google AI Overviews and AI Mode, Gemini, and Claude. These engines retrieve pages
from a search index first and then quote passages that answer the question cleanly,
so a page has to be findable, and then easy to lift and safe to cite. You work on the
second part and check the first.

You're done when the post answers its core question in its opening, each section
leads with a self-contained answer, every important claim is specific and sourced,
the trust signals are visible, and the user knows which off-page steps matter.

## What helps and what doesn't

Give the user this distinction plainly, because the AEO and GEO space is full of
paid advice that isn't backed by the engines themselves.

What helps, and why:
- Ranking. AI features retrieve from the same index and ranking systems as regular
  search, often for several related sub-queries at once. A page that can't rank for
  any of them rarely gets cited.
- Front-loaded answers. Engines quote the opening of a page far more than the end.
- Self-contained, specific sentences with numbers, names, and dates. Engines quote
  sentences, not pages.
- Focused pages. A page that answers one question well beats an "ultimate guide"
  that answers twenty thinly.
- First-hand experience, original data, and a named author with real credentials.
  These make a quote safe to cite.
- Freshness that's real. ChatGPT and Perplexity lean toward recently updated pages,
  and a substantive update is worth showing with a visible date.
- Mentions elsewhere. Engines weigh what other sites, forums, and videos say about a
  brand, not only what the brand says about itself.

What doesn't, per Google's own guidance on AI search:
- An `llms.txt` file. Google Search ignores it, and there's no evidence it earns
  citations elsewhere.
- Chopping a page into tiny chunks or rewriting it in a special "AI style."
- Special schema for AI features. Structured data still helps regular rich results
  (Article, Product, VideoObject), but FAQ markup no longer produces rich results for
  most sites.
- A separate page for every phrasing of a question. That's scaled content abuse, and
  it can get a site demoted.
- Self-ranked "best X" lists that put the publisher first. Engines tend to cite those
  pages while leaving the publisher out of the answer.

[references/evidence.md](https://skilld.dev/api/skills-raw/rightblogger/bloggingskills/ai-seo/references/evidence.md) has the sources and numbers behind
these, dated. Cite them when the user asks why.

## Initial assessment

- If `.agents/blog-context.md` exists, read it for the author, credentials, and the
  "Experience and proof" section. A captured voice still wins over any rule here.
- Read the house-style rulebook at `../house-style/references/ai-tells.md` before you
  write any new sentence.
- Take the post as text or a URL. State the one question it answers in a sentence. If
  you can't, the page has no answer for an engine to lift; fix that first.
- If you can search the web, look at how AI answers currently handle the question and
  which pages they cite. That's the bar.
- If the post is stale (old prices, versions, or a past year in the title), say so
  first and point to refresh. Engines favor current pages, and no amount of
  restructuring makes an outdated answer safe to cite.

## Method

Audit against these checks, then apply or propose each edit.

1. Answer first. The core question gets a direct, self-contained answer in the first
   100 words, about 40 to 60 words long, quotable with no surrounding context. When
   this collides with another rule, a clear, quotable answer beats an exact word
   count.
2. Opening third. The key facts, numbers, and the main recommendation appear in the
   first third of the post, not saved for the end.
3. Section leads. Each H2 opens with one or two sentences that answer that section's
   question on their own. Rewrite headings toward how people actually ask only where
   that is how they search.
4. Sub-questions. List the follow-up questions a person (or an engine's fan-out)
   would ask next. Cover the missing ones inside this page, briefly. Don't propose new
   pages for each.
5. Specifics. Replace vague claims with numbers, names, dates, and sources. Flag any
   claim with no source rather than invent one.
6. Trust signals. A named author with relevant credentials, a visible publish or
   updated date, first-hand evidence (a test, a photo, original data), and links to
   primary sources.
7. One summary, not two. The answer-first opening from check 1 is the summary
   engines quote. Add a separate "Key takeaways" list only to a long reference post
   readers will scan, and then make sure the conclusion doesn't recap the same
   points: a takeaways box plus a recap close is the shape readers and detectors
   flag as generated (see evidence.md). An existing TL;DR, Summary, or At a glance
   block stays only on a long reference post; otherwise move any fact only it holds
   into the opening and remove it.
8. FAQ. Add 3 to 5 questions only if readers still have real questions the body
   didn't answer. It's for readers and answer engines, not for rich results.
9. Access. If you can read the site's `robots.txt`, confirm it doesn't block the
   search crawlers the user cares about: Googlebot, Bingbot (Copilot draws on Bing),
   OAI-SearchBot for ChatGPT search, Claude-SearchBot, and PerplexityBot.
   Blocking a training crawler like GPTBot doesn't remove a site from those search
   results. For Google, two more switches decide eligibility: the site must be
   opted in to generative AI features in Search Console (an opted-out site gets no
   AI Overview or AI Mode citations), and the page must allow a snippet, so check
   for `nosnippet`, a tiny `max-snippet`, or `data-nosnippet` on the answer. If you
   can't see these settings, ask the user to confirm them.

One answer-first opening is the point. Don't stack summary boxes.

## Output

1. If the user asked a direct question (llms.txt, schema, a specific engine), answer
   it first in a few lines.
2. A short audit: which of the nine checks the post fails, worst first.
3. The edits, ready to paste, in this order: the answer-first opening, the takeaways
   list if the post earned one, the rewritten section leads, the added sub-question
   coverage, and the FAQ if it earned one.
4. Off-page steps, in two or three lines: where the brand should be mentioned or
   reviewed, a YouTube video if the topic suits one, and how to watch results. AI
   referrers (chatgpt.com, perplexity.ai, gemini.google.com, copilot.microsoft.com,
   claude.ai) belong in their own analytics channel. Search Console's generative AI
   report and Bing's AI Performance report show citations and impressions but not
   clicks, so read them as visibility, not traffic.

Don't restate the post back to the user.

## Related skills

seo-optimize · serp-analysis · refresh · article · humanize · house-style
