Answer Engine Optimization Checklist: 24 Checks With the Code

This is the implementation companion to What is AEO. That article explains why the answer surface works the way it does. This one is the checklist, in dependency order, with the code you need for each check.

TL;DR

Work the checklist in order, because the sections are dependencies rather than a menu. Access before structure, structure before authority, measurement before any of it. A blocked crawler makes every later check irrelevant, and it is a one-line fix, so checking it first can save you a quarter of misdirected work.

The single highest-yield check is section 1. AI engines crawl with their own user agents, and a robots.txt written for traditional SEO frequently blocks some of them through a rule nobody has revisited. Blocked access is the most common cause of a zero citation rate, produces no error message anywhere, and looks exactly like a content problem from the outside.

Verification is part of every check. A schema block that fails validation is discarded silently, so an invalid block and a missing block are indistinguishable. Each check below includes how to confirm it landed, because in this domain nothing tells you when it did not.

Section 1: Crawler Access (Do This First)

1. Allow each AI crawler by name in robots.txt

Do not assume a permissive wildcard covers them, and do not assume a rule you wrote for scrapers is not catching them. List each agent explicitly:

User-agent: GPTBot
Allow: /

User-agent: ChatGPT-User
Allow: /

User-agent: OAI-SearchBot
Allow: /

User-agent: ClaudeBot
Allow: /

User-agent: Claude-User
Allow: /

User-agent: PerplexityBot
Allow: /

User-agent: Perplexity-User
Allow: /

User-agent: Google-Extended
Allow: /

User-agent: CCBot
Allow: /

User-agent: Applebot-Extended
Allow: /

Two notes. Google-Extended controls Gemini and AI Overviews use and is entirely separate from Googlebot, so blocking it removes you from Google's answer surface while leaving your rankings untouched. Applebot-Extended is likewise separate from Applebot. Each vendor also splits training crawlers from live-fetch agents, GPTBot versus ChatGPT-User being the clearest case, and they serve different purposes: the live-fetch agent is what retrieves a page during an actual conversation, so blocking it costs you real-time citations.

Decide deliberately whether to admit training crawlers such as CCBot. Excluding them is a legitimate business choice. Excluding the live-fetch agents means opting out of being cited at all.

2. Verify robots.txt actually serves what you think

Fetch it as a crawler would rather than trusting your source file. A misconfigured redirect, a stale CDN cache, or a framework rewrite can serve something other than what you deployed:

curl -sS "https://example.com/robots.txt?cb=$(date +%s)" -H "Cache-Control: no-cache"

The cache-buster matters. Edge-cached responses will happily show you the old file for hours after a deploy, which is how people conclude a fix did not work when it did, or that it did work when it did not.

3. Confirm crawlers are arriving, in your own logs

This is the only proof that access works. Your server logs already record it:

grep -iE 'GPTBot|ClaudeBot|PerplexityBot|Google-Extended|CCBot|Bytespider' access.log \
  | awk '{print $NF}' | sort | uniq -c | sort -rn

For reference, our logs for echloe.io over one week in late July and early August 2026 recorded 172 AI crawler visits from 8 bots: ClaudeBot 82, ChatGPT-User 39, GPTBot 31, Bytespider 7, PerplexityBot 7, CCBot 3, Applebot 2, Google-Extended 1. That is a modest site. If you see zero across a week, you have an access problem regardless of what robots.txt says.

4. Confirm content is in the HTML, not only in JavaScript

Some AI crawlers execute JavaScript inconsistently or not at all. Content that only exists after hydration may be invisible to them even though it renders perfectly in your browser. Check the raw response:

curl -sS https://example.com/your-page | grep -c "a distinctive phrase from your answer block"

A count of zero means the crawler that does not run JavaScript sees an empty page. Server-render or statically generate anything you want cited.

5. Confirm the page is indexable and canonical

An answer engine will not favor a page you have told search engines to ignore. Verify there is no noindex, that the canonical URL points at the page itself rather than elsewhere, and that the URL in your canonical exactly matches the URL you promote, including protocol, trailing slash, and www. A canonical mismatch splits your signals across URLs that each look weaker than the page really is.

6. Add llms.txt

A machine-readable summary of your site's key content at /llms.txt. It is cheap, increasingly recognized, and gives a model a curated map instead of whatever it discovers by crawling:

# Example Inc

> One-sentence description of what the company does.

Core content
- What is AEO: Definition and implementation guide
- Product: What we build and who it is for

Contact
- [email protected]

Section 2: Answer Block Structure

7. Phrase headings as the questions people actually ask

"How Much Does AEO Cost?" beats "Pricing Considerations." The heading is a boundary marker telling a machine what the passage below answers, and a vague heading makes it guess.

8. Answer in the first sentence beneath the heading

No warm-up, no context-setting, no restating the question. The answer, then the reasoning. This inverts the usual instinct to build toward a conclusion, and it reads better for humans in a hurry too.

9. Make every answer passage self-contained

The test is mechanical. Read a passage with everything else on the page hidden. If it opens with "this means," refers to an undefined "it," or assumes a definition given three sections earlier, it fails, and an engine that lifts it produces something incoherent or skips it.

10. Target roughly 130 to 170 words per answer passage

Long enough to be complete, short enough to quote whole. Passages substantially longer tend to be truncated at a point you did not choose.

11. Write one explicit definition sentence per key term

Use the pattern [Term] is [definition] in a single sentence. Models extract definitions from this pattern reliably and from a discursive explanation of the same concept much less reliably. Put it first in the section that introduces the term.

12. Include a TL;DR that summarizes rather than teases

Two to four paragraphs stating the actual conclusions. A summary promising insight further down gets extracted as your answer and delivers nothing, which is a worse outcome than not being extracted.

13. Replace generalities with specifics

Every "many companies" and "significantly faster" is an extraction opportunity wasted. Numbers, dates, and named sources are checkable, and models cite checkable claims far more readily. First-party data is strongest here because nobody else has it.

14. Use tables for comparisons

Comparative questions are disproportionately common on the answer surface, and a table gives a machine explicit row and column relationships instead of prose it must parse into a structure.

15. Add an FAQ section that answers questions the body does not

Not a restatement of your headings. Use it for the adjacent questions a reader asks next, which is also where conversational follow-up queries land.

Section 3: Structured Data

16. Add Article schema with honest dates

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Answer Engine Optimization Checklist",
  "datePublished": "2026-08-05",
  "dateModified": "2026-08-05",
  "author": { "@type": "Organization", "name": "Example Inc" },
  "publisher": {
    "@type": "Organization",
    "name": "Example Inc",
    "logo": { "@type": "ImageObject", "url": "https://example.com/logo.png" }
  },
  "mainEntityOfPage": {
    "@type": "WebPage",
    "@id": "https://example.com/blog/your-slug"
  }
}

dateModified is the field that earns its keep, because generative systems weight recency heavily and cannot see an update you did not declare. Update it when you substantively revise the page, and only then. Touching it without changing anything is a signal you will regret teaching people to distrust.

17. Add FAQPage schema matching your visible FAQ

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "What is an answer block?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "An answer block is a passage that completely answers one specific question and makes sense in isolation."
    }
  }]
}

The text must match what a user sees. Schema describing content that is not on the page is a violation of Google's structured data policies and risks a manual action.

18. Add HowTo schema for procedures

If the page contains ordered steps, declare them. HowTo with step entries gives a machine the sequence explicitly instead of requiring it to infer order from your numbering.

19. Add Organization schema with sameAs

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Example Inc",
  "url": "https://example.com",
  "logo": "https://example.com/logo.png",
  "description": "One consistent sentence about what you do.",
  "sameAs": [
    "https://www.linkedin.com/company/example",
    "https://x.com/example",
    "https://github.com/example"
  ]
}

This is the entity check. sameAs is how you tell a model that these scattered profiles are one entity, which is what lets it attribute to you confidently. Models are conservative about citing identities they cannot resolve, because attributing wrongly is a worse failure than not attributing.

20. Validate every block, and re-validate after deploy

Invalid schema is discarded silently. Use Google's Rich Results Test and the Schema.org validator, then check the deployed page rather than your local copy, since a build step can mangle JSON-LD.

Section 4: Entity and Authority Signals

21. Keep naming and self-description consistent everywhere

Same organization name, same capitalization, same one-sentence description on your site, your profiles, and your listings. A model reconciling three conflicting self-descriptions has three reasons to cite someone whose identity is unambiguous.

22. Make author identity resolvable

An author page with a real biography, not a name string. Then reference it consistently. Anonymous content is harder to attribute and therefore less likely to be cited.

23. Build brand mentions, not only backlinks

Profound's analysis of 11.84 billion citations found roughly 43% pointed at sites the brand does not own, and in pharma and biotech earned media alone supplied 59%. You cannot edit those pages, which makes this closer to public relations than to link building: a different activity with a different owner. Treating authority as one undifferentiated budget line is how this half silently gets nothing.

Section 5: Measurement

24. Instrument all three surfaces before optimizing

Three plausible diagnoses, three completely different responses, and they are indistinguishable if you track one metric.

Rankings. Search Console. One trap: the API returns rows sorted by clicks and then truncates at your row limit, so a high-impression page with no clicks can fall outside a small window and disappear from your own reporting. Use a high row limit and sort by impressions yourself before drawing conclusions.

Citations. No console exists. Write down 20 questions a buyer would genuinely ask, run them against ChatGPT, Perplexity, and Google AI Overviews on a schedule, and record whether you appear. Twenty questions across three engines is under an hour a month by hand and is a real baseline. Tools automate the frequency and breadth rather than providing a different signal; we compare them in Best GEO Tools 2026.

Crawler visits. The leading indicator, from check 3. Crawler traffic appears weeks before citations.

Read them together. Heavy crawling with zero citations means access is fine and authority or depth is the constraint. Zero crawling means the models never saw the page and no rewriting will help. Our own reading of these two numbers is 172 crawler visits and a zero citation rate across 54 test queries and three engines, which tells us our constraint is authority, not access. Reporting an unfinished result is more useful than implying the checklist produces citations quickly on a young domain.

What to Do First If You Only Have an Hour

Checks 1 through 3, then check 24. Confirm the crawlers are allowed, confirm robots.txt actually serves that, confirm visits are arriving in your logs, and establish a citation baseline you can compare against later.

That hour tells you which of the remaining checks matter. If crawlers are blocked, fix that and change nothing else, because you may be done. If they are arriving and you have no citations, the work is content depth and authority, which is sections 2 through 4 and a quarter rather than an afternoon.

The free audit at echloe.io automates most of sections 1 through 3 against a URL and returns the findings in priority order, if you would rather not work the list by hand.

FAQ

What is the most important AEO check?

Crawler access, by a wide margin. AI engines use their own user agents, and if robots.txt blocks GPTBot, ClaudeBot, PerplexityBot, or Google-Extended, no content or schema work can produce a citation because the content is unreachable. It is a one-line fix, it produces no error message anywhere you would look, and from the outside it looks identical to a content quality problem. Check it first and verify against your server logs rather than your config file.

Does blocking GPTBot hurt my Google rankings?

No. GPTBot is OpenAI's crawler and has no relationship to Google. The crawler that affects Google's answer surface is Google-Extended, which controls use in Gemini and AI Overviews and is separate from Googlebot. Blocking Google-Extended removes you from Google's AI answers while leaving your traditional rankings unaffected, which is a real trade to make deliberately rather than by accident.

How long should an answer block be?

Roughly 130 to 170 words. Long enough to answer the question completely without depending on surrounding context, short enough for an engine to quote whole rather than truncating it at a point you did not choose. The length matters less than the self-containment: test each passage by reading it with the rest of the page hidden and confirming it still answers the question.

Do I need FAQPage schema if my FAQ is already visible on the page?

It helps meaningfully, because schema converts an inference into a declaration. Without it, a machine has to guess where each answer begins and ends from your heading structure. With it, the boundaries are explicit. The requirement is that the schema text matches the visible content exactly; schema describing content that is not on the page violates Google's structured data policies and risks a manual action.

How often should I update dateModified?

Only when you substantively revise the page. Generative systems weight recency heavily, so an honest dateModified on a genuinely updated page is valuable. Touching the field without changing content is the kind of signal that stops being useful for everyone once enough people do it, and it gives you no way to tell your real updates apart from your fake ones.

Can I do AEO without any paid tools?

Yes, and all 24 checks above are doable at zero cost. Your server logs provide crawler data. Google's Rich Results Test and the Schema.org validator handle schema validation. Search Console covers rankings. A manual prompt set run monthly covers citations. Paid platforms buy frequency, engine breadth, and retained history rather than a different signal, and they are much easier to evaluate once you know which of the three diagnoses you are dealing with.