AI Engine Optimization (AEO/GEO)

Optimize frontend code and content to maximize visibility and citation-worthiness across AI platforms including ChatGPT, Perplexity, Claude, Gemini, Copilot, and Google AI Overviews.

Core Principles: The AEO Triad

1. Structure (Machine-Readable Signals)

AI systems extract meaning from structured data. JSON-LD schemas provide explicit signals about content type, authorship, and relationships that AI can parse reliably.

2. Citation-Worthiness (Content Quality)

AI systems cite sources that provide authoritative, factual, well-organized information. Content must earn citation through clarity, accuracy, and usefulness.

3. Accessibility (Technical Discoverability)

Content must be crawlable and indexable. SPAs need special consideration. AI crawlers have different behaviors than traditional search bots.

SEO vs AEO: Complementary Differences

Aspect	Traditional SEO	AI Engine Optimization
Primary goal	Rank in search results	Get cited in AI responses
Content format	Keyword-optimized	Answer-first, factual density
Signals	Backlinks, keywords	Structured data, E-E-A-T
User journey	Click through to site	Answer consumed in AI
Measurement	Rankings, clicks	Mentions, citations
Time horizon	Weeks to months	Immediate (live) + months (training)

AEO complements SEO - well-structured, authoritative content benefits both.

Quick Start Patterns

Essential Structured Data

Every public page needs at minimum:

Organization schema on homepage
WebSite schema with search action
WebPage or Article schema on content pages
FAQPage schema where applicable

Basic implementation with useSEO hook:

import { useSEO } from '@/hooks/useSEO';

function LandingPage() {
  useSEO({
    title: 'Product Name - Concise Value Proposition',
    description: 'Direct answer to what this product does. Specific benefits with measurable outcomes.',
    canonicalUrl: 'https://example.com/',
    schemas: [
      {
        id: 'organization-schema',
        data: {
          '@context': 'https://schema.org',
          '@type': 'Organization',
          name: 'Company Name',
          url: 'https://example.com',
          description: 'What the company does in one clear sentence.',
          // See references/structured-data-patterns.md for complete fields
        }
      },
      {
        id: 'website-schema',
        data: {
          '@context': 'https://schema.org',
          '@type': 'WebSite',
          name: 'Site Name',
          url: 'https://example.com',
          potentialAction: {
            '@type': 'SearchAction',
            target: 'https://example.com/search?q={search_term}',
            'query-input': 'required name=search_term'
          }
        }
      }
    ]
  });
  // ...
}

Content Structure Pattern

Lead with direct answers, then elaborate:

## What is [Topic]?

[Topic] is [one-sentence definition with key characteristics].

### Key Features

| Feature | Description | Benefit |
|---------|-------------|---------|
| Feature 1 | What it does | Why it matters |
| Feature 2 | What it does | Why it matters |

### How [Topic] Works

1. **First step**: Specific action with concrete details
2. **Second step**: Specific action with measurable outcome
3. **Third step**: Specific action with expected result

### Frequently Asked Questions

**Q: Common question about topic?**
A: Direct answer in 1-2 sentences. Additional context if needed.

E-E-A-T Implementation

Experience, Expertise, Authoritativeness, Trustworthiness:

// Author schema for blog posts
const authorSchema = {
  '@context': 'https://schema.org',
  '@type': 'Person',
  name: 'Author Name',
  url: 'https://example.com/about/author-name',
  jobTitle: 'Senior Engineer',
  worksFor: {
    '@type': 'Organization',
    name: 'Company Name'
  },
  sameAs: [
    'https://linkedin.com/in/author',
    'https://github.com/author'
  ]
};

Implementation by Task

Creating/Optimizing Pages

Read references/structured-data-patterns.md for appropriate schemas
Read references/content-optimization.md for content structure
Read references/react-implementation.md for technical patterns

Auditing Existing Pages

Read references/audit-checklist.md for quick assessment
Test with Schema.org validator
Test AI retrieval across platforms

Understanding AI Crawlers

Read references/ai-crawler-guide.md for crawler behaviors
Configure robots.txt appropriately
Consider prerendering for SPAs

Content Strategy

Read references/content-optimization.md for citation patterns
Focus on factual density and answer-first structure
Implement multi-format redundancy

Critical AEO Patterns

Pattern 1: Factual Density

Bad:

Our solution helps many companies improve their results.

Good:

Our platform monitors brand mentions across 12 AI systems, tracking over 50,000 prompts daily with 94% accuracy in sentiment classification.

Specific numbers, measurable claims, and verifiable facts earn citations.

Pattern 2: Answer-First Structure

Bad:

When considering the various aspects of our approach, it's important to understand the historical context...

Good:

Brand monitoring works by tracking AI responses to industry-relevant prompts. Here's how:

Define tracking prompts

Query AI platforms via API

Analyze responses for brand mentions

Lead with the answer. Elaborate after.

Pattern 3: Q&A Format

Questions users actually ask, with direct answers:

const faqSchema = {
  '@context': 'https://schema.org',
  '@type': 'FAQPage',
  mainEntity: [
    {
      '@type': 'Question',
      name: 'How do I track my brand in ChatGPT?',
      acceptedAnswer: {
        '@type': 'Answer',
        text: 'Track your brand in ChatGPT by querying the API with industry-relevant prompts and analyzing responses for brand mentions. Tools like visibility monitors automate this process.'
      }
    }
  ]
};

Pattern 4: Hierarchical Authority

Structure content from general to specific:

# Category (H1)
## Subcategory (H2)
### Specific Topic (H3)
#### Implementation Detail (H4)

Use semantic HTML: <article>, <section>, <nav>, <aside>.

Pattern 5: Multi-Format Redundancy

Present key information in multiple formats:

Prose: Narrative explanation
Tables: Comparison data
Lists: Step-by-step processes
Code: Implementation examples

AI systems may extract from any format - redundancy increases citation likelihood.

Pattern 6: Source Attribution

Cite authoritative sources:

Link to primary sources
Reference industry standards
Quote experts with attribution

Content that cites well is more likely to be cited.

Common Mistakes

Keyword Stuffing

AI systems detect unnatural keyword density. Write for humans; structured data handles machine signals.

Thin Content

Pages with minimal substantive content won't earn citations. Each page should answer a specific question thoroughly.

Missing Structured Data

Without JSON-LD, AI systems rely on inference. Explicit schemas dramatically improve extraction accuracy.

SPA Rendering Issues

Client-rendered content may not be visible to crawlers. Implement prerendering or SSR for public-facing pages.

Ignoring Live vs Training

AI systems have two access modes:

Live retrieval: Real-time crawling (Perplexity, Copilot with search)
Training data: Periodic crawl snapshots (base ChatGPT, Claude)

Optimize for both timeframes.

Blocked Crawlers

Check robots.txt - some sites accidentally block AI crawlers while allowing Googlebot.

Schema Quick Reference

Organization

{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "Company Name",
  "url": "https://example.com",
  "logo": "https://example.com/logo.png",
  "description": "What the company does.",
  "foundingDate": "2020",
  "address": {
    "@type": "PostalAddress",
    "addressLocality": "City",
    "addressRegion": "State",
    "addressCountry": "US"
  }
}

Article

{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Article Title",
  "author": {
    "@type": "Person",
    "name": "Author Name"
  },
  "datePublished": "2024-01-15",
  "dateModified": "2024-01-20",
  "publisher": {
    "@type": "Organization",
    "name": "Publisher Name"
  }
}

FAQPage

{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [{
    "@type": "Question",
    "name": "Question text?",
    "acceptedAnswer": {
      "@type": "Answer",
      "text": "Answer text."
    }
  }]
}

See references/structured-data-patterns.md for complete schema library.

Measurement

Testing AI Retrieval

ChatGPT: Ask questions your content should answer
Perplexity: Search for your brand/topic, check citations
Claude: Query with relevant prompts
Google AI Overview: Search and check AI-generated summaries

Key Metrics

Citation presence: Is your content cited?
Citation accuracy: Is the information correctly extracted?
Brand mention sentiment: How is your brand characterized?
Competitive visibility: How do you compare to competitors?

Testing Structured Data

Google Rich Results Test: https://search.google.com/test/rich-results
Schema.org Validator: https://validator.schema.org/
Browser DevTools: Check application/ld+json scripts

Integration Notes

This skill integrates with existing codebase patterns:

useSEO hook: Located at src/hooks/useSEO.js - supports multiple schemas
Organization schema: Pattern at src/seo/organizationSchema.js
MDX blog system: Content at src/content/blog/

When implementing, extend existing patterns rather than creating parallel systems.

Reference Files

For detailed implementation guidance:

references/structured-data-patterns.md - Complete JSON-LD schema library
references/content-optimization.md - Content patterns for AI citation
references/react-implementation.md - React/Vite technical patterns
references/ai-crawler-guide.md - AI crawler behaviors and configuration
references/audit-checklist.md - Quick-reference audit checklists