SearchFit Plugin + Claude Code: The Dev Workflow

Introduction: Why Your Dev Team Needs AEO Instrumentation in Claude Code

Your SEO visibility is leaking to AI answer engines. ChatGPT, Perplexity, Gemini, and Claude are answering user queries before they ever reach your organic search results, and most B2B SaaS teams have zero visibility into whether their content is even being cited.

The problem gets worse when you're trying to optimize for AI search at scale. You need to:

• Track which pages are cited in ChatGPT, Perplexity, Gemini, and Claude responses
• Understand what content patterns trigger AI citations
• Instrument your site with structured data and metadata that AI engines recognize
• Test changes across multiple AI platforms without manual checking
• Automate the feedback loop between ranking data and content iteration

Manual tracking doesn't scale. Spreadsheets break. Slack notifications get ignored. And by the time your marketing team flags a visibility gap, your competitors are already ranking.

Enter Claude Code paired with the SearchFit Plugin. This combination turns answer engine optimization (AEO) from a guessing game into an automated, developer-driven workflow. Claude Code handles the heavy lifting, parsing AI responses, instrumenting pages, running tests, while SearchFit tracks the results across all major AI platforms.

This guide walks you through the exact workflow: how to set up the SearchFit Plugin inside Claude Code, instrument your site for AEO, track performance across ChatGPT, Perplexity, Gemini, and Claude, and automate content optimization at scale.

Prerequisites: What You Need Before Starting

Before you begin, confirm you have the following in place:

Technical Requirements

• Claude Code Access: You need Claude 3.5 Sonnet or later with Claude Code enabled. If you're not yet using Claude Code, you can enable it in your Claude settings or request access through the Anthropic console.
• SearchFit Account: A SearchFit subscription with API access enabled. You'll need your API key and workspace ID from the SearchFit dashboard.
• Git Repository: A version-controlled codebase (GitHub, GitLab, or Bitbucket) where your site's content and metadata live. Claude Code integrates directly with Git, so this is essential for committing instrumentation changes.
• Node.js or Python Environment: Claude Code can scaffold either. We recommend Node.js 18+ for faster iteration, but Python 3.9+ works equally well.
• Curl or HTTPClient Library: For testing API calls to SearchFit and AI platforms. Claude Code includes built-in HTTP support, but you may want a standalone tool for manual verification.

Knowledge Prerequisites

• Familiarity with JSON and structured data (schema.org, Open Graph)
• Basic understanding of how AI citation works (what SearchFit tracks)
• Git workflow basics (branching, committing, pushing)
• Comfort reading API documentation and JSON responses

Access & Permissions

• SearchFit API Key: Retrieve this from your SearchFit workspace settings under Integrations → API Keys. Store it as an environment variable (e.g., SEARCHFIT_API_KEY).
• Git Write Access: You need permission to push branches and create pull requests in your repository.
• Site Access: Ability to modify HTML/metadata on your live or staging site. If you're working on a staging environment first (recommended), ensure staging is publicly accessible so AI crawlers can reach it.

Step 1: Install and Configure the SearchFit Plugin in Claude Code

The SearchFit Plugin acts as a bridge between Claude Code and the SearchFit platform. It lets Claude fetch your current AI visibility data, trigger new scans, and log instrumentation changes back to SearchFit.

1.1 Access the Claude Code Workspace

Open Claude and create a new Code session. You'll see a sidebar with options to create a new project or open an existing one. Click New Project and name it something descriptive like searchfit-aeo-instrumentation.

Clause Code will scaffold a basic project structure. You don't need to use it, you can point Claude to an existing repository instead. If you have a repo already, paste the GitHub/GitLab URL and Claude will clone it.

1.2 Add the SearchFit Plugin

In the Claude Code left sidebar, look for Plugins or Extensions. Click the + button to add a new plugin. You'll see a marketplace of available plugins.

Search for SearchFit. The official SearchFit Plugin will appear with the SearchFit logo. Click Install.

If you don't see it in the marketplace, you can add it manually:

1. In your project's package.json (Node.js) or requirements.txt (Python), add the SearchFit plugin dependency:

• Node.js: npm install @searchfit/claude-plugin - Python: pip install searchfit-claude-plugin

1. Create a .env file in your project root and add your credentials:

SEARCHFIT_API_KEY=your_api_key_here SEARCHFIT_WORKSPACE_ID=your_workspace_id_here SEARCHFIT_API_BASE_URL=https://api.searchfit.ai

1. In your main script (e.g., index.js or main.py), import the plugin:

• Node.js: const SearchFitPlugin = require('@searchfit/claude-plugin'); - Python: from searchfit_claude_plugin import SearchFitPlugin

1.3 Initialize the Plugin in Claude Code

Once installed, tell Claude Code to initialize the plugin. In the Claude Code chat, type:

Initialize the SearchFit Plugin with my workspace ID and API key from the environment.

Claude will automatically load your credentials and test the connection. You should see a confirmation message like:

✓ SearchFit Plugin initialized
✓ Connected to workspace: [your-workspace-name]
✓ API key validated

If you get an authentication error, double-check that your API key is correct and that your SearchFit subscription includes API access.

1.4 Verify Plugin Commands

The SearchFit Plugin exposes several commands that Claude Code can call. Test them by asking Claude:

List all available SearchFit Plugin commands.

You should see output like:

• searchfit.getVisibility(), Fetch current AI visibility across all platforms
• searchfit.getVisibilityByEngine(), Get visibility broken down by ChatGPT, Perplexity, Gemini, Claude
• searchfit.scanDomain(), Trigger a new scan of your domain
• searchfit.getCitations(), Fetch all recent AI citations
• searchfit.logInstrumentation(), Log metadata changes to SearchFit
• searchfit.getAnalytics(), Fetch detailed analytics and trends

Note these commands, you'll use them in the workflow steps below.

Step 2: Audit Your Current AI Visibility Baseline

Before you start instrumenting, you need a baseline. What's your current visibility across ChatGPT, Perplexity, Gemini, and Claude? Which pages are being cited? Which are missing?

2.1 Fetch Your Current Visibility Report

In Claude Code, ask:

Fetch my current AI visibility report from SearchFit. Show me:
- Total citations in the last 30 days
- Breakdown by AI engine (ChatGPT, Perplexity, Gemini, Claude)
- Top 10 cited pages
- Pages with zero citations

Claude will call searchfit.getVisibility() and return a structured report. You'll see something like:

\{
"totalCitations": 1247,
"period": "last_30_days",
"byEngine": \{
"chatgpt": 456,
"perplexity": 389,
"gemini": 267,
"claude": 135
\},
"topCitedPages": [
\{
"url": "/blog/what-is-aeo",
"citations": 89,
"engines": ["chatgpt", "perplexity", "gemini"]
\},
// ... more pages
],
"uncitedPages": [
\{
"url": "/pricing",
"citations": 0,
"reason": "Low keyword relevance"
\},
// ... more pages
]
\}

2.2 Identify Instrumentation Gaps

Look at your uncited pages and low-citation pages. Ask Claude to analyze why:

Analyze the uncited pages in my visibility report. For each page, tell me:
- Current meta tags and structured data
- Missing Open Graph or schema.org tags
- Content gaps compared to cited competitors
- Recommended instrumentation changes

Claude will fetch your page metadata (by reading your HTML or asking you to paste it) and compare it to pages that are getting cited. This usually reveals patterns:

• Missing or incomplete Open Graph tags
• No author information or publication date
• Lack of schema.org Article or FAQPage markup
• Missing internal linking to other authoritative content
• Thin content (< 1500 words) on topics where competitors have 3000+ word deep dives

Document these gaps. They're your instrumentation roadmap.

2.3 Export the Baseline to Your Repository

Ask Claude to create a baseline report file in your repo:

Create a file called `aeo-baseline-report.json` in the project root with today's visibility snapshot. Include:
- Date captured
- All metrics from the visibility report
- List of pages to prioritize for instrumentation
- Estimated impact (how many citations we could gain if we fix each gap)

Claude will generate and commit this file. You now have a before-and-after reference point.

Step 3: Set Up Your AEO Instrumentation Framework

Now you're going to build the actual instrumentation system. This is a set of scripts and templates that Claude Code will use to systematically add AEO metadata to your pages.

3.1 Create the Instrumentation Config File

Ask Claude to scaffold your instrumentation configuration:

Create an `aeo-config.json` file that defines:
- Which pages to instrument (by URL pattern or content type)
- Required metadata fields (title, description, author, publication date, etc.)
- Schema.org types to apply (Article, FAQPage, HowTo, etc.)
- Open Graph tags to include
- Custom SearchFit tracking parameters

Claude will generate something like:

\{
"version": "1.0",
"instrumentation": \{
"blog": \{
"urlPattern": "/blog/*",
"schemaType": "Article",
"requiredFields": [
"headline",
"description",
"author",
"datePublished",
"dateModified",
"image",
"wordCount",
"keywords"
],
"openGraph": \{
"type": "article",
"tags": ["og:title", "og:description", "og:image", "og:url", "article:published_time", "article:author"]
\},
"searchfitTracking": \{
"contentType": "blog",
"priority": "high"
\}
\},
"documentation": \{
"urlPattern": "/docs/*",
"schemaType": "FAQPage",
"requiredFields": [
"headline",
"description",
"dateModified",
"breadcrumb"
],
"openGraph": \{
"type": "website",
"tags": ["og:title", "og:description", "og:url"]
\},
"searchfitTracking": \{
"contentType": "docs",
"priority": "high"
\}
\},
"product_pages": \{
"urlPattern": "/product/*",
"schemaType": "Product",
"requiredFields": [
"name",
"description",
"image",
"price",
"availability"
],
"openGraph": \{
"type": "product",
"tags": ["og:title", "og:description", "og:image", "og:price"]
\},
"searchfitTracking": \{
"contentType": "product",
"priority": "medium"
\}
\}
\},
"globalTags": \{
"twitter:card": "summary_large_image",
"canonical": "auto",
"viewport": "width=device-width, initial-scale=1.0"
\}
\}

Edit this to match your site structure. Commit it to your repo.

3.2 Build the Instrumentation Script

Now ask Claude to create the main instrumentation engine:

Create an `aeo-instrumenter.js` (or `.py` if Python) script that:
1. Reads aeo-config.json
2. Scans all HTML files matching the URL patterns
3. For each file, extracts current metadata
4. Compares current metadata against required fields in the config
5. Generates an instrumentation report showing what's missing
6. Can apply fixes (add missing tags, update schema.org markup) with a --apply flag
7. Logs all changes to a JSON audit trail

This script becomes your workhorse. Here's the rough structure Claude will build:

// aeo-instrumenter.js (Node.js example)
const fs = require('fs');
const cheerio = require('cheerio');
const config = require('./aeo-config.json');

class AEOInstrumenter \{
constructor() \{
this.auditTrail = [];
this.config = config;
\}

async scanPages() \{
// Find all HTML files
// For each file, extract metadata
// Compare against config requirements
// Return gaps and recommendations
\}

async applyInstrumentation(pageUrl, fixes) \{
// Read HTML file
// Add/update metadata tags
// Update schema.org markup
// Write changes back to file
// Log to audit trail
\}

async generateReport() \{
// Summarize all gaps
// Estimate impact (citations gained)
// Prioritize by engine (ChatGPT vs Perplexity, etc.)
\}
\}

Commit this script to your repo. You're building an automated AEO pipeline.

3.3 Create HTML Templates for Each Content Type

Ask Claude:

Create HTML template files for each content type in aeo-config.json:
- blog-template.html (for Article schema)
- docs-template.html (for FAQPage schema)
- product-template.html (for Product schema)

Each template should include:
- All required meta tags
- Properly formatted schema.org markup
- Open Graph tags
- SearchFit tracking parameters
- Placeholder variables for dynamic content (\{\{title\}\}, \{\{author\}\}, etc.)

These templates ensure consistency across your site. When you add new content, you'll use these as starting points.

Step 4: Instrument Your Site Pages

Now you're ready to actually add AEO metadata to your pages. This is where the SearchFit Plugin and Claude Code really accelerate things.

4.1 Run the Initial Instrumentation Scan

In Claude Code, type:

Run the aeo-instrumenter.js scan on our entire site. Show me:
- Total pages scanned
- Pages with complete metadata
- Pages with gaps (missing tags/schema)
- Breakdown of missing elements by type
- Estimated citations we could gain by fixing each gap

Claude will execute the script and generate a detailed report. You might see:

✓ Scanned 143 pages
✓ 89 pages (62%) have complete metadata
✓ 54 pages (38%) have gaps

Most common gaps:
- Missing author field (32 pages)
- Missing datePublished (28 pages)
- Incomplete schema.org markup (21 pages)
- No Open Graph image (19 pages)

Estimated impact:
- Fixing author fields: +12-18 citations/month
- Adding datePublished: +8-14 citations/month
- Completing schema: +25-40 citations/month

4.2 Prioritize Pages by Opportunity

Ask Claude:

Rank the 54 pages with gaps by opportunity. Prioritize by:
1. Current citation count (pages already getting cited but missing metadata)
2. Search volume (pages targeting high-volume keywords)
3. Competitive position (pages where competitors are cited more)
4. Ease of fix (pages where adding metadata is simple)

Create a prioritized list with a recommended order for instrumentation.

Claude will generate a CSV or JSON file ranking pages. Your top priority might look like:

[
\{
"url": "/blog/what-is-answer-engine-optimization",
"currentCitations": 12,
"gaps": ["author", "datePublished"],
"estimatedGain": "8-12 citations",
"effort": "low",
"priority": 1
\},
\{
"url": "/docs/api",
"currentCitations": 3,
"gaps": ["schema.org", "breadcrumb"],
"estimatedGain": "15-20 citations",
"effort": "medium",
"priority": 2
\}
]

Start with your top 10-15 pages. You can parallelize across multiple Claude Code sessions if you want to move faster.

4.3 Instrument the Top Priority Pages

For your first batch, ask Claude:

Instrument the top 5 priority pages from the prioritized list. For each page:
1. Read the current HTML
2. Add missing author field (use [your-author-name] or fetch from git history)
3. Add datePublished (use the file creation date or git commit date)
4. Update/complete schema.org markup for Article
5. Add Open Graph tags
6. Create a commit message describing the changes
7. Do NOT push yet, create a local branch called `aeo/instrumentation-batch-1`

Claude will:

• Read each page's HTML
• Parse existing metadata
• Add missing elements
• Write changes back to files
• Create a Git branch and stage the changes

You'll see output like:

✓ Instrumented /blog/what-is-answer-engine-optimization
- Added author: Jane Doe
- Added datePublished: 2024-01-15
- Updated Article schema (added articleBody, keywords)
- Added og:image

✓ Instrumented /blog/aeo-vs-seo
- Added author: John Smith
- Added datePublished: 2024-01-20
- Updated Article schema
- Added og:image

[5 pages instrumented]

✓ Created branch: aeo/instrumentation-batch-1
✓ Staged 5 file changes

4.4 Review Changes Before Committing

Before you push, review what Claude changed:

Show me a diff of all changes in the aeo/instrumentation-batch-1 branch. Highlight:
- All new meta tags added
- Schema.org changes
- Any content modifications (there should be none)

Claude will show you a side-by-side diff. Verify that:

• Only metadata was added (no content changes)
• Tags are properly formatted
• Schema.org markup is valid JSON-LD
• No accidental deletions

If something looks wrong, ask Claude to fix it before committing.

4.5 Commit and Push

Once you're satisfied:

Commit the aeo/instrumentation-batch-1 branch with a clear message:
"AEO: Add author, datePublished, and schema.org markup to top 5 blog posts

Instrumented pages:
- /blog/what-is-answer-engine-optimization
- /blog/aeo-vs-seo
- [3 more]

Changes:
- Added author field to all pages
- Added datePublished (from git history)
- Completed Article schema.org markup
- Added Open Graph tags

Expected impact: +8-15 citations/month"

Then push to origin.

Claude will create the commit and push. Now create a pull request:

Create a pull request from aeo/instrumentation-batch-1 to main with the commit message as the PR description.

Your team can review and merge. Once merged, the instrumented pages go live.

4.6 Repeat for Remaining Pages

Repeat steps 4.3-4.5 for your next batch of pages. You can run multiple batches in parallel:

Instrument pages 6-10 from the priority list. Create a branch called aeo/instrumentation-batch-2.

Batch processing lets you instrument your entire site in days, not weeks.

Step 5: Integrate with SearchFit Tracking and AI Tracking

Instrumentation is only half the battle. You also need to track results. SearchFit's AI tracking capabilities monitor which pages get cited after you publish changes.

5.1 Log Instrumentation Changes to SearchFit

As you instrument pages, tell SearchFit about it:

For each instrumented page, call searchfit.logInstrumentation() with:
- Page URL
- Metadata fields added (author, datePublished, schema.org type, etc.)
- Timestamp of change
- Expected impact (estimated citations gained)

Ask Claude:

After each instrumentation batch is merged, log the changes to SearchFit:

For each of the 5 pages in batch-1, call searchfit.logInstrumentation() with:
\{
"pageUrl": "https://yourdomain.com/blog/...",
"changes": \{
"author": "added",
"datePublished": "added",
"schema.org": "updated",
"openGraph": "added"
\},
"timestamp": "2024-01-25T14:30:00Z",
"expectedImpact": "8-15 citations/month"
\}

SearchFit logs these changes internally. It uses them to correlate instrumentation with citation increases.

5.2 Set Up Automated Scans

Now that your pages are instrumented, SearchFit needs to re-scan them across all AI engines. Ask Claude:

Trigger a SearchFit scan for all instrumented pages using searchfit.scanDomain().
After the scan completes, fetch the updated visibility report and compare it to our baseline.

SearchFit will crawl ChatGPT, Perplexity, Gemini, and Claude to see if your pages are now being cited. This takes 24-48 hours for a full scan.

5.3 Monitor Citation Growth

While waiting for scan results, set up automated monitoring:

Create a monitoring script that:
1. Every 6 hours, calls searchfit.getVisibility()
2. Compares current citations to the baseline
3. Calculates citation growth by engine (ChatGPT, Perplexity, etc.)
4. Logs results to a CSV file (aeo-monitoring.csv)
5. Alerts if a page's citations drop unexpectedly

Claude will create this script. You can run it with:

node aeo-monitor.js

Or set it as a cron job to run automatically.

5.4 Create a Dashboard with Analytics

SearchFit's analytics dashboard shows your performance visually. But you can also build a custom dashboard in your repo:

Create an HTML dashboard (aeo-dashboard.html) that:
1. Fetches real-time data from SearchFit via searchfit.getAnalytics()
2. Displays:
- Total citations (all engines)
- Citations by engine (ChatGPT, Perplexity, Gemini, Claude)
- Top cited pages
- Citation growth over time (graph)
- Pages with zero citations
- Estimated monthly citation impact
3. Updates every hour
4. Shows comparison to baseline

Deploy this dashboard internally so your team can see AEO progress in real-time.

Step 6: Automate Content Testing Across AI Engines

Once pages are instrumented, you want to test variations. Which title gets cited more in ChatGPT? Which description in Perplexity? Claude Code + SearchFit can automate this.

6.1 Create A/B Test Framework

Ask Claude:

Create an A/B testing framework that:
1. Takes a page URL and a list of variations (different titles, descriptions, etc.)
2. For each variation, creates a temporary branch with the change
3. Deploys to a staging environment
4. Waits 24 hours for SearchFit to scan the staged version
5. Compares citation rates between variations
6. Reports the winner
7. Merges the winning variation to production

This is where you get scientific about AEO. You're not guessing anymore, you're testing.

6.2 Test Title Variations

Start with titles. Ask Claude:

Create an A/B test for /blog/what-is-answer-engine-optimization.

Variation A (current): "What Is Answer Engine Optimization? A Complete Guide"
Variation B: "Answer Engine Optimization (AEO): How to Rank in ChatGPT & Perplexity"
Variation C: "AEO 101: Getting Your Content Cited by AI Search Engines"

For each variation:
1. Create a staging branch
2. Update the page title and og:title
3. Deploy to staging
4. Wait for SearchFit to scan
5. Report citation rates for each

Claude will orchestrate the entire test. After 24-48 hours, you'll see which title variation gets cited most.

6.3 Test Schema.org and Metadata Variations

You can also test different schema.org types or metadata fields:

Create an A/B test for our documentation pages.

Variation A (current): FAQPage schema
Variation B: HowTo schema
Variation C: Article schema with breadcrumb

Test which schema type gets cited most in Perplexity and Gemini.

This teaches you which AI engines prefer which content structures.

6.4 Automate Multi-Engine Testing

Here's where it gets powerful. Ask Claude to build a testing framework that considers all engines:

Create a multi-engine testing script that:
1. Takes a page and a set of variations
2. For each variation, tracks citations separately by engine:
- ChatGPT citations
- Perplexity citations
- Gemini citations
- Claude citations
3. Identifies which variation wins in each engine
4. Recommends a "global" winner (best average) or engine-specific winners
5. Logs all results to a CSV for analysis

Now you can optimize differently for different engines. Maybe Perplexity prefers HowTo schema while ChatGPT prefers Article schema. You can tailor your content accordingly.

Step 7: Scale Instrumentation with Automation

You've instrumented your top pages. Now automate the rest.

7.1 Create a Content Intake Pipeline

When new content is published, it should be automatically instrumented. Ask Claude:

Create a GitHub Actions workflow that:
1. Triggers when a new file is added to /blog or /docs
2. Reads the file
3. Checks it against aeo-config.json
4. Identifies missing metadata
5. If gaps exist:
- Creates a branch called `aeo/auto-instrument-[page-slug]`
- Adds missing metadata (using templates)
- Creates a pull request with a checklist for the author to review
6. If complete, adds a label `aeo-ready` to the PR

Now every new page is automatically reviewed for AEO completeness before it goes live.

7.2 Set Up Continuous Monitoring

Ask Claude to build a monitoring pipeline:

Create a daily scheduled task that:
1. Calls searchfit.getVisibility() to get latest citation data
2. Compares to yesterday's data
3. Identifies pages with declining citations
4. Creates an alert (Slack message, email, etc.) if a page drops >20% citations
5. Logs all trends to a CSV for monthly review

Now you're not just tracking AEO, you're actively monitoring for regressions.

7.3 Automate Competitor Analysis

You can also use Claude Code to track how competitors are cited:

Create a competitor monitoring script that:
1. Takes a list of competitor domains
2. For each competitor, calls searchfit.getCitations() to see where they're cited
3. Compares their citation patterns to yours
4. Identifies gaps (topics where they're cited but you're not)
5. Recommends content to create or optimize

This turns SearchFit data into a content roadmap.

Step 8: Integrate with Your Existing Workflow

AEO instrumentation works best when it's part of your normal development process, not a separate project.

8.1 Add AEO Checklist to PR Templates

Update your GitHub pull request template to include AEO checks:

## AEO Checklist

- [ ] Page has author field
- [ ] Page has datePublished or dateModified
- [ ] Page has appropriate schema.org markup (Article, FAQPage, etc.)
- [ ] Page has Open Graph tags
- [ ] Page title is optimized for AI citation
- [ ] Page description is clear and AI-friendly
- [ ] Internal links to related content are included
- [ ] Page length meets minimum (1500+ words for blog, 800+ for docs)

If any box is unchecked, the aeo/auto-instrument workflow will add missing metadata.

Now every PR is reviewed for AEO before merge.

8.2 Integrate with Your CI/CD Pipeline

Add AEO checks to your CI/CD:

Create a GitHub Actions workflow that:
1. On every push to main, runs the aeo-instrumenter.js scan
2. Fails the build if any page is missing critical metadata
3. Reports gaps in the build output
4. Prevents merging until all AEO requirements are met (or creates an auto-fix PR)

This makes AEO non-negotiable.

8.3 Add AEO to Your Deployment Process

When you deploy to production, trigger a SearchFit scan:

Create a post-deployment hook that:
1. After successful deployment to production
2. Calls searchfit.scanDomain() to re-scan your site
3. Waits for the scan to complete (24-48 hours)
4. Compares new citations to pre-deployment baseline
5. Sends a report to your Slack channel with citation impact

Now you see the real-world impact of your instrumentation work.

Step 9: Troubleshooting and Common Issues

Here are problems you might hit and how to fix them.

Issue: SearchFit Plugin Won't Initialize

Symptom: "Authentication failed" or "API key invalid"

Fix:

1. Verify your API key in SearchFit dashboard (Connectors → API Keys)
2. Check that your .env file has the correct key (no extra spaces or quotes)
3. Confirm your workspace ID matches your SearchFit account
4. If using a staging environment, ensure it's publicly accessible (AI crawlers need to reach it)
5. Restart Claude Code and try again

Issue: Pages Instrumented But No Citation Increase

Symptom: You added metadata, but SearchFit shows zero new citations after 48 hours

Fix:

1. Verify the page is actually live and accessible
2. Check that schema.org markup is valid JSON (use schema.org validator)
3. Ensure Open Graph tags match the actual page content (AI engines check for consistency)
4. Check if the page is targeting keywords with low AI citation volume (not all queries get answered by AI)
5. Wait longer, some AI engines take 7-14 days to re-crawl pages
6. Ask Claude to compare your page structure to highly-cited competitor pages

Issue: Claude Code Can't Read My HTML Files

Symptom: "File not found" or "Permission denied" errors

Fix:

1. Ensure your repository is cloned locally in Claude Code
2. Check file paths are relative to the project root
3. If files are in a subdirectory, use the full path (e.g., src/pages/blog/post.html)
4. Verify file permissions (should be readable by your user)
5. If using a monorepo, specify the correct subdirectory

Issue: Git Commits Failing

Symptom: "Failed to commit" or "Branch already exists"

Fix:

1. Ensure you're not on a protected branch (main, master)
2. Check that your git config is set up correctly (name, email)
3. If branch already exists, ask Claude to use a different branch name
4. Verify you have write access to the repository
5. Pull the latest changes before creating a new branch

Issue: SearchFit Scan Not Completing

Symptom: Scan initiated but status stays "pending" after 48 hours

Fix:

1. Check if your site has robots.txt or meta robots tags blocking crawlers
2. Verify that AI crawler IPs aren't blocked by your firewall
3. Check site uptime (if your site was down during the scan, it may have failed)
4. If using staging, ensure it's not behind authentication
5. Contact SearchFit support if the issue persists

Step 10: Measure Impact and Iterate

Instrumentation is not a one-time project. You need to measure results and continuously improve.

10.1 Create a Monthly AEO Report

Ask Claude to build a monthly reporting script:

Create a script that generates a monthly AEO report showing:
1. Total citations this month vs. last month (% change)
2. Citations by engine (ChatGPT, Perplexity, Gemini, Claude)
3. Top 10 gaining pages (biggest citation increases)
4. Top 10 declining pages (biggest citation decreases)
5. Pages still with zero citations (opportunities)
6. Estimated traffic impact (based on citation → click-through assumptions)
7. Recommended optimizations for next month

Run this every month and share with your team.

10.2 Track ROI

Measure the business impact:

Create an ROI calculation that:
1. Estimates traffic from AI citations (e.g., 1 citation = 0.5-2 clicks depending on engine)
2. Values that traffic at your average customer lifetime value
3. Compares ROI of AEO work to other marketing initiatives
4. Shows payback period (how long until AEO instrumentation pays for itself)

This justifies continued investment in AEO.

10.3 Iterate on Instrumentation

Based on monthly data, refine your approach:

After reviewing the monthly report, ask Claude:

"Based on this month's citation data, what should we optimize next?
- Which pages are losing citations and why?
- Which content types (Article, FAQPage, etc.) perform best in each engine?
- Are there content gaps where competitors are cited but we're not?
- What new metadata or schema should we test?

Create a prioritized list of optimizations for next month."

AEO is iterative. Each month, you get smarter about what works.

Best Practices and Pro Tips

Pro Tip 1: Start with High-Volume Keywords

Instrument pages targeting keywords with high AI citation volume first. These will show results faster and build momentum. Use SearchFit's analytics to identify which keywords get cited most across engines.

Pro Tip 2: Match Content to Engine Preferences

Different AI engines have different content preferences:

• ChatGPT: Prefers long-form, authoritative content with clear structure
• Perplexity: Cites diverse sources; benefits from unique perspectives and original data
• Gemini: Favors content with strong E-E-A-T signals (experience, expertise, authoritativeness, trustworthiness)
• Claude: Prefers nuanced, well-reasoned content with clear citations

Use your A/B test data to tailor content for each engine.

Pro Tip 3: Link Internally Strategically

AI engines reward sites with strong internal linking. When you instrument a page, also ensure it links to 3-5 related pages on your site. This creates a content network that AI engines recognize as authoritative.

Pro Tip 4: Monitor Competitor Instrumentation

Use Claude Code to periodically analyze competitor pages:

Fetch the top 3 competitors' pages that are cited for [keyword].
Analyze their metadata, schema.org markup, and content structure.
Identify what we're missing.

Stay ahead of competitors by copying their best practices.

Pro Tip 5: Use Staging for Testing

Always test instrumentation changes on staging before pushing to production. This lets you verify that:

• Metadata renders correctly
• Schema.org is valid
• No content is accidentally modified
• Links work

Ask Claude to deploy to staging, wait 24 hours for SearchFit to scan, then review results before merging to production.

Advanced: Scaling Across Multiple Sites

If you're managing AEO for multiple client sites or brands, you can scale this workflow.

Multi-Site Configuration

Ask Claude to create a configuration that manages multiple sites:

Create a multi-site aeo-config.json that:
1. Defines settings for 5+ sites
2. Allows site-specific instrumentation rules
3. Manages SearchFit API credentials per site
4. Generates separate reports for each site
5. Tracks performance across all sites in one dashboard

Parallel Instrumentation

Run multiple Claude Code sessions in parallel, one per site:

Session 1: Instrument site A (50 pages)
Session 2: Instrument site B (75 pages)
Session 3: Instrument site C (30 pages)

Each session works independently, so you can instrument multiple sites simultaneously.

Centralized Monitoring

Create a master dashboard that aggregates data from all sites:

Create a dashboard that shows:
- Total citations across all sites
- Citations by site
- Citations by engine (global view)
- Top performing pages across all sites
- Opportunities (pages with zero citations across all sites)

This gives you a bird's-eye view of AEO performance across your entire portfolio.

Conclusion: Your AEO Automation is Live

You've now built a complete, automated AEO instrumentation system. Here's what you have:

✓ Baseline Visibility: You know exactly where your brand is cited (or not cited) across ChatGPT, Perplexity, Gemini, and Claude.

✓ Instrumentation Framework: A config-driven system that standardizes metadata across your site and ensures every new page meets AEO requirements.

✓ Automated Scanning: SearchFit continuously monitors your visibility and alerts you to changes.

✓ A/B Testing: You can test title variations, schema types, and metadata to find what gets cited most.

✓ Continuous Monitoring: Daily tracking of citation growth, with alerts for regressions.

✓ Scalable Pipeline: New content is automatically instrumented before it goes live.

✓ Measurement: Monthly reports showing ROI and guiding next month's optimizations.

The SearchFit Plugin + Claude Code combination turns AEO from a manual, guesswork process into a systematic, data-driven operation. You're not hoping your content gets cited, you're engineering it.

Next steps:

1. Deploy your first batch of instrumented pages to production (this week)
2. Monitor results for 48 hours as SearchFit re-scans (next week)
3. Review the impact and iterate on your top 10 pages (week 2)
4. Automate new content intake so every new page is AEO-ready (week 3)
5. Scale to all pages over the next month
6. Build your competitive advantage by testing and optimizing continuously

Your competitors are still manually checking if they're cited in ChatGPT. You're automating the entire workflow. That's the difference between hoping for AI visibility and building it systematically.

Start with SearchFit today, integrate the plugin into Claude Code, and watch your AI citations grow.