---
name: geo-ghost-stack
description: Audit or scaffold the "Seven-Layer Ghost Stack" — the full set of machine-readable signals (meta tags, JSON-LD schemas, sr-only narrative, microdata, llms.txt, reasoning.json, /.well-known/ai-manifest.json) that let a web page get discovered and cited by AI systems (ChatGPT, Perplexity, Gemini, Claude, Copilot) and ranked quickly by Google/Bing. Use this skill whenever the user talks about Generative Engine Optimization (GEO), AI SEO, AI citation, LLM visibility, structured data, schema.org, JSON-LD, llms.txt, ai-manifest, AEO, getting a site "indexed by ChatGPT", making a website "AI-readable", or auditing a site's metadata — even if they don't use the term "Ghost Stack". Also trigger on requests like "make my site show up in AI answers", "add schema to my landing page", "why isn't ChatGPT finding my site", or "review the SEO of this HTML file".
---

# GEO Ghost Stack: Audit & Build AI-Citation Signals

This skill helps you do two jobs on a website:

1. **Audit** — scan an existing site (URL or local HTML) and report which of the seven AI-readability layers are present, missing, or broken.
2. **Build** — scaffold any missing layers using the included templates, wired to the facts the user gives you (brand, author, definitions, FAQs).

The seven layers, in order of increasing specificity:

| # | Layer | File(s) | Audience |
|---|---|---|---|
| 1 | Semantic meta tags + VibeTags | `<head>` | Crawlers, social unfurlers |
| 2 | JSON-LD structured data | `<script type="application/ld+json">` | Google rich results, AI extractors |
| 3 | sr-only narrative content | `<main class="sr-only">` | Screen readers, DOM-parsing AIs |
| 4 | Microdata attributes | `itemscope` / `itemprop` / `data-*` | Entity extractors |
| 5 | llms.txt | `/llms.txt`, `/llms-full.txt` | LLM crawlers (emerging standard) |
| 6 | reasoning.json (ARP) | `/reasoning.json` | Agentic Reasoning Protocol consumers |
| 7 | AI discovery manifest | `/.well-known/ai-manifest.json` | AI bot discovery |

The architecture pattern is documented on phantomauthority.ai, which reached AI and Google indexing within 36 hours of launch using these layers alone.

## When to use this skill

Trigger on any of: "check the SEO of…", "make this site AI-ready", "add structured data / schema / JSON-LD", "why isn't [ChatGPT | Perplexity | Gemini | Claude] citing my site?", "review my meta tags", "add an llms.txt", "set up ai-manifest", "GEO audit", "AEO", "generative search optimization", or when the user pastes HTML and asks for a visibility/schema/metadata review.

Do **not** use this skill for: purely visual design, traditional link-building SEO advice, or Google Ads / paid-search tuning. Those are adjacent but out of scope.

## Workflow

### Step 1 — Figure out which job the user wants

Use this decision tree:

- User gave you an existing URL or HTML file → **Audit first**, then propose a build plan for the gaps.
- User has a blank site or wants to start from scratch → **Interview, then build** directly.
- User said "check AND fix" → Audit, show the report, then build the missing pieces.

If you're not sure, ask one question before you start: *"Do you want me to audit what's already there, scaffold the whole stack from scratch, or both?"*

### Step 2 — Gather the minimum facts you need to build

Before generating any files, collect the following from the user. Don't guess these; empty or placeholder values defeat the entire purpose of the stack, because AI systems weigh specificity heavily.

Required:

- **Canonical URL** (e.g. `https://example.com`)
- **Site / project name**
- **One-sentence description** (the "definition" the AI should cite)
- **Author name + role + author URL** (LinkedIn, personal site, etc.)
- **Publisher / organization name + URL**
- **Primary topic/keyword** (the thing you want AI systems to cite you as an authority on)
- **3–8 FAQ pairs** the site should answer definitively

Strongly recommended:

- 2–5 defined terms the site is claiming canonical authority over (name + 1–2 sentence definition each)
- A list of `sameAs` URLs for the author/org (LinkedIn, GitHub, Wikipedia, Crunchbase, etc.) — these anchor the entity in the knowledge graph
- A published date (`YYYY-MM-DD`)
- Brand "vibe" words: essence, tone, sentiment, aesthetic, authority claim, mission (these feed VibeTags)

If you build a stack with empty descriptions, no FAQs, and no sameAs links, tell the user directly: *"I can scaffold the files, but without real definitions, FAQs, and sameAs links the stack will be a shell — AI systems will skip it. Let's fill these in."*

### Step 3 — Audit (if applicable)

To audit a URL or HTML file, use `scripts/audit.py`. It fetches the page (if a URL), parses the HTML, and reports per-layer presence, counts, and obvious problems.

```bash
python scripts/audit.py --url https://example.com
# or
python scripts/audit.py --file /path/to/index.html
```

The script returns JSON with a score (0–100), per-layer status, and a `missing` list. Use that output to decide what to build next.

When reading the output, think of scores like this:
- **0–30**: No AI-readable layer at all. Scaffold the whole stack.
- **31–60**: Basic meta + maybe one schema. Add JSON-LD, sr-only narrative, and the three file-based layers (5, 6, 7).
- **61–85**: Most structure is present. Focus on entity density (sameAs, defined terms), FAQPage schema, and the `.well-known` manifest.
- **86–100**: Ship it. Spot-check for staleness (dateModified, broken sameAs URLs).

If the script can't run (no network, no Python), do the audit by reading the HTML manually using the checklist in `references/audit-checklist.md`.

### Step 4 — Build

For each layer you need to add or replace, use the corresponding reference + template:

| Layer | Reference | Template / asset |
|---|---|---|
| 1. Meta + VibeTags | `references/layer-1-meta-tags.md` | `assets/templates/head-template.html` |
| 2. JSON-LD | `references/layer-2-jsonld-schemas.md` | `assets/schemas/*.json` |
| 3. sr-only narrative | `references/layer-3-sr-only-narrative.md` | `assets/templates/sr-only-narrative.html` |
| 4. Microdata | `references/layer-4-microdata.md` | inline examples in reference |
| 5. llms.txt | `references/layer-5-llms-txt.md` | `assets/templates/llms.txt` |
| 6. reasoning.json | `references/layer-6-reasoning-json.md` | `assets/templates/reasoning.json` |
| 7. ai-manifest | `references/layer-7-ai-manifest.md` | `assets/templates/ai-manifest.json` |

Read the relevant reference file before touching the template. Each one explains why the fields matter and which ones are load-bearing vs. nice-to-have. Skipping the reference and just filling in placeholders is the most common failure mode.

For a one-shot scaffold of the whole stack, use `scripts/scaffold.py`:

```bash
python scripts/scaffold.py --config site.yaml --out ./public
```

Where `site.yaml` is the facts gathered in Step 2. The script emits `index.html` (layers 1–4 baked in), `llms.txt`, `llms-full.txt`, `reasoning.json`, and `.well-known/ai-manifest.json` into `./public`. See `scripts/example-site.yaml` for the expected shape.

### Step 5 — Verify

After building, always do these three checks, because silent schema errors are the #1 reason AI systems skip a site:

1. Paste each JSON-LD block into Google's Rich Results Test (`https://search.google.com/test/rich-results`) or Schema Markup Validator (`https://validator.schema.org/`).
2. Curl each served file directly — `curl https://yoursite.com/llms.txt`, `/reasoning.json`, `/.well-known/ai-manifest.json` — to confirm they return 200 with `text/plain` or `application/json` content-type.
3. View-source the page and grep for every required meta name. If anything is missing, don't mark the job done.

Tell the user the verification results explicitly before you declare the stack "live".

## Key principles

**Specificity over volume.** One precise, well-linked JSON-LD `DefinedTerm` beats ten vague `keywords` entries. AI systems reward entity density, not keyword stuffing.

**Self-consistency across layers.** The same claim ("Sascha Deforth coined Phantom Authority in April 2026") should appear in at least three layers: JSON-LD ScholarlyArticle, sr-only narrative, and reasoning.json. Repetition across structured formats is how machines confirm a fact is load-bearing rather than incidental.

**This is not cloaking.** The sr-only pattern puts content in the DOM for all visitors, identical HTML for humans and bots — it just doesn't render visually. That's how Bootstrap, Tailwind, and every WCAG-compliant site does screen-reader text. Explain this to the user if they're nervous about Google penalties.

**Canary tokens.** When the user's goal is to *measure* whether AI systems pick the site up, bake in one or two unique phrases that exist nowhere else on the internet. Later, searching the open web for those phrases shows whether the citation came from their page.

**Don't invent facts.** If the user hasn't given you a LinkedIn URL, don't fabricate one for `sameAs`. A broken or wrong sameAs hurts the entity signal more than an absent one.

## Compatibility

Works with Claude Code, Claude Agent SDK, Codex CLI, Cursor, and any agent runtime that can read the SKILL.md convention. The scripts need Python 3.9+ and (for the audit script) the `requests` and `beautifulsoup4` packages — installable with `pip install requests beautifulsoup4 pyyaml`.