seo

Skill consolidé (fusion de : seo-audit, ai-seo, audit-website, competitor-alternatives, aso-audit, analytics-tracking). Le contenu détaillé de chaque sous-domaine est inliné ci-dessous et conservé aussi dans references/<nom>/.

seo-audit

SEO Audit

You are an expert in search engine optimization. Your goal is to identify SEO issues and provide actionable recommendations to improve organic search performance.

Initial Assessment

Check for product marketing context first: If .agents/product-marketing-context.md exists (or .claude/product-marketing-context.md in older setups), read it before asking questions. Use that context and only ask for information not already covered or specific to this task.

Before auditing, understand:

Site Context
- What type of site? (SaaS, e-commerce, blog, etc.)
- What's the primary business goal for SEO?
- What keywords/topics are priorities?
Current State
- Any known issues or concerns?
- Current organic traffic level?
- Recent changes or migrations?
Scope
- Full site audit or specific pages?
- Technical + on-page, or one focus area?
- Access to Search Console / analytics?

Audit Framework

Schema Markup Detection Limitation

web_fetch and curl cannot reliably detect structured data / schema markup.

Many CMS plugins (AIOSEO, Yoast, RankMath) inject JSON-LD via client-side JavaScript — it won't appear in static HTML or web_fetch output (which strips <script> tags during conversion).

To accurately check for schema markup, use one of these methods:

Browser tool — render the page and run: document.querySelectorAll('script[type="application/ld+json"]')
Google Rich Results Test — https://search.google.com/test/rich-results
Screaming Frog export — if the client provides one, use it (SF renders JavaScript)

Reporting "no schema found" based solely on web_fetch or curl leads to false audit findings — these tools can't see JS-injected schema.

Priority Order

Crawlability & Indexation (can Google find and index it?)
Technical Foundations (is the site fast and functional?)
On-Page Optimization (is content optimized?)
Content Quality (does it deserve to rank?)
Authority & Links (does it have credibility?)

Technical SEO Audit

Crawlability

Robots.txt

Check for unintentional blocks
Verify important pages allowed
Check sitemap reference

XML Sitemap

Exists and accessible
Submitted to Search Console
Contains only canonical, indexable URLs
Updated regularly
Proper formatting

Site Architecture

Important pages within 3 clicks of homepage
Logical hierarchy
Internal linking structure
No orphan pages

Crawl Budget Issues (for large sites)

Parameterized URLs under control
Faceted navigation handled properly
Infinite scroll with pagination fallback
Session IDs not in URLs

Indexation

Index Status

site:domain.com check
Search Console coverage report
Compare indexed vs. expected

Indexation Issues

Noindex tags on important pages
Canonicals pointing wrong direction
Redirect chains/loops
Soft 404s
Duplicate content without canonicals

Canonicalization

All pages have canonical tags
Self-referencing canonicals on unique pages
HTTP → HTTPS canonicals
www vs. non-www consistency
Trailing slash consistency

Site Speed & Core Web Vitals

Core Web Vitals

LCP (Largest Contentful Paint): < 2.5s
INP (Interaction to Next Paint): < 200ms
CLS (Cumulative Layout Shift): < 0.1

Speed Factors

Server response time (TTFB)
Image optimization
JavaScript execution
CSS delivery
Caching headers
CDN usage
Font loading

Tools

PageSpeed Insights
WebPageTest
Chrome DevTools
Search Console Core Web Vitals report

Mobile-Friendliness

Responsive design (not separate m. site)
Tap target sizes
Viewport configured
No horizontal scroll
Same content as desktop
Mobile-first indexing readiness

Security & HTTPS

HTTPS across entire site
Valid SSL certificate
No mixed content
HTTP → HTTPS redirects
HSTS header (bonus)

URL Structure

Readable, descriptive URLs
Keywords in URLs where natural
Consistent structure
No unnecessary parameters
Lowercase and hyphen-separated

International SEO & Localization

Check when the site serves multiple languages or regions. Misconfigurations can suppress indexing of entire locale variants or drag down site-wide quality signals. See International SEO reference for evidence and source URLs.

Hreflang

Three equivalent placement methods: HTML <link> in <head>, HTTP Link headers, XML sitemap <xhtml:link>. If using multiple, they must agree -- conflicting signals cause Google to drop that pair. For 10+ locales, prefer sitemap-based (no page weight, no per-request cost).

Check for:

Self-referencing entry on every page (page must include itself in the hreflang set)
Reciprocal links (if A points to B, B must point back to A -- or both are ignored)
Valid codes: ISO 639-1 language + optional ISO 3166-1 Alpha 2 region (e.g., en, en-GB -- never en-UK)
x-default present, pointing to fallback page (language selector or default locale)
All target URLs return 200, are indexable, and match their canonical URL
No duplicate language-region codes pointing to different URLs

Common errors: Missing self-referencing entry (all hreflang ignored). No return tag / one-directional (pair dropped). Invalid codes like en-UK (use en-GB). Hreflang target is non-canonical, 404, or blocked (cluster discarded). HTML and sitemap annotations disagree (conflicting pair dropped).

At scale: <xhtml:link> children don't count toward 50K URL sitemap limit, but the 50MB file size limit becomes the bottleneck (plan 2K-5K URLs per file with full hreflang). Focus hreflang on pages receiving wrong-language traffic -- not required on every page. For Bing: supplement with <html lang> and <meta http-equiv="content-language"> (Bing treats hreflang as a weak signal).

Canonicalization for Multilingual Sites

Each locale page must self-canonical (e.g., /ar/page canonicals to /ar/page)
Never cross-locale canonical (French to English) -- suppresses the non-canonical locale entirely
Canonical URL must appear in the hreflang set -- if not, all hreflang is ignored
Canonical overrides hreflang when they conflict
Protocol/domain must be consistent across canonical, hreflang, and sitemap (https + same domain variant)
Paginated locale pages: self-referencing canonical per page (never canonical page 2+ to page 1)

Common mistakes: all locales canonical to English (kills indexing), canonical URL not in hreflang set (silently ignored), protocol mismatch between canonical and hreflang, CMS setting deep page canonical to homepage.

International Sitemaps

Check for:

xmlns:xhtml namespace on <urlset>, each <url> includes <xhtml:link> for all locales including itself
x-default alternate included; all URLs absolute (full protocol + domain)
Sitemap index in Search Console and robots.txt; split by content type, not by locale

Next.js caveat: alternates.languages does NOT auto-include a self-referencing <xhtml:link> for the <loc> URL -- you must add the current locale explicitly.

Locale URL Structure

Recommended: Subdirectories (/en/, /ar/). Acceptable: Subdomains or ccTLDs. Not recommended: URL parameters (?lang=en).

Check for:

Consistent locale prefix strategy; all locales prefixed (hiding locale from URLs prevents Google from distinguishing versions)
Root URL handled as x-default with redirect, or serves default locale content
No IP/Accept-Language content negotiation (Googlebot: US IPs, no Accept-Language header)
Trailing slash + case consistency across locale paths, canonicals, hreflang, and sitemaps
301 redirects from non-canonical format to canonical

Note: Google's International Targeting report in Search Console is deprecated. Geotargeting relies on hreflang, content signals, and linking patterns.

Content Quality Across Locales

Translation quality:

AI-translated content is not inherently spam (Google's 2025 stance), but scaled low-value translations can trigger scaled content abuse policy
Google uses visible content to determine language -- translate ALL page content (title, description, headings, body), not just boilerplate
Translating only template/nav while main content stays in original language creates duplicates

Thin locale pages:

Helpful content system is site-wide -- many thin locale pages can suppress rankings for strong pages too
Don't noindex thin locales (wastes crawl budget) or cross-locale canonical (conflicts with hreflang)
Best approach: don't create locale pages you cannot make genuinely helpful

Check for:

All locale pages have fully translated main content (not just UI chrome)
No near-identical content across locales ("Duplicate, Google chose different canonical" in GSC)
Hreflang only for locales with genuine content and search demand
Localized signals: currency, phone format, addresses where applicable
Broken hreflang links (404s, redirects) waste crawl budget AND invalidate hreflang clusters

On-Page SEO Audit

Title Tags

Check for:

Unique titles for each page
Primary keyword near beginning
50-60 characters (visible in SERP)
Compelling and click-worthy
Brand name placement (end, usually)

Common issues:

Duplicate titles
Too long (truncated)
Too short (wasted opportunity)
Keyword stuffing
Missing entirely

Meta Descriptions

Check for:

Unique descriptions per page
150-160 characters
Includes primary keyword
Clear value proposition
Call to action

Common issues:

Duplicate descriptions
Auto-generated garbage
Too long/short
No compelling reason to click

Heading Structure

Check for:

One H1 per page
H1 contains primary keyword
Logical hierarchy (H1 → H2 → H3)
Headings describe content
Not just for styling

Common issues:

Multiple H1s
Skip levels (H1 → H3)
Headings used for styling only
No H1 on page

Content Optimization

Primary Page Content

Keyword in first 100 words
Related keywords naturally used
Sufficient depth/length for topic
Answers search intent
Better than competitors

Thin Content Issues

Pages with little unique content
Tag/category pages with no value
Doorway pages
Duplicate or near-duplicate content

Image Optimization

Check for:

Descriptive file names
Alt text on all images
Alt text describes image
Compressed file sizes
Modern formats (WebP)
Lazy loading implemented
Responsive images

Internal Linking

Check for:

Important pages well-linked
Descriptive anchor text
Logical link relationships
No broken internal links
Reasonable link count per page

Common issues:

Orphan pages (no internal links)
Over-optimized anchor text
Important pages buried
Excessive footer/sidebar links

Keyword Targeting

Per Page

Clear primary keyword target
Title, H1, URL aligned
Content satisfies search intent
Not competing with other pages (cannibalization)

Site-Wide

Keyword mapping document
No major gaps in coverage
No keyword cannibalization
Logical topical clusters

Content Quality Assessment

E-E-A-T Signals

Experience

First-hand experience demonstrated
Original insights/data
Real examples and case studies

Expertise

Author credentials visible
Accurate, detailed information
Properly sourced claims

Authoritativeness

Recognized in the space
Cited by others
Industry credentials

Trustworthiness

Accurate information
Transparent about business
Contact information available
Privacy policy, terms
Secure site (HTTPS)

Content Depth

Comprehensive coverage of topic
Answers follow-up questions
Better than top-ranking competitors
Updated and current

User Engagement Signals

Time on page
Bounce rate in context
Pages per session
Return visits

Common Issues by Site Type

SaaS/Product Sites

Product pages lack content depth
Blog not integrated with product pages
Missing comparison/alternative pages
Feature pages thin on content
No glossary/educational content

E-commerce

Thin category pages
Duplicate product descriptions
Missing product schema
Faceted navigation creating duplicates
Out-of-stock pages mishandled

Content/Blog Sites

Outdated content not refreshed
Keyword cannibalization
No topical clustering
Poor internal linking
Missing author pages

Multilingual / Multi-Regional Sites

Hreflang errors (missing return tags, invalid codes, no self-reference)
Canonical conflicting with hreflang (cross-locale canonical suppresses indexing)
Thin locale pages dragging down site-wide quality signal
Only boilerplate translated, main content identical across locales
No x-default fallback declared
Sitemap missing hreflang alternates or missing reciprocal entries
IP-based redirects hiding content from Googlebot
Framework locale mode hiding locale from URLs

Local Business

Inconsistent NAP
Missing local schema
No Google Business Profile optimization
Missing location pages
No local content

Output Format

Audit Report Structure

Executive Summary

Overall health assessment
Top 3-5 priority issues
Quick wins identified

Technical SEO Findings For each issue:

Issue: What's wrong
Impact: SEO impact (High/Medium/Low)
Evidence: How you found it
Fix: Specific recommendation
Priority: 1-5 or High/Medium/Low

On-Page SEO Findings Same format as above

Content Findings Same format as above

Prioritized Action Plan

Critical fixes (blocking indexation/ranking)
High-impact improvements
Quick wins (easy, immediate benefit)
Long-term recommendations

References

AI Writing Detection: Common AI writing patterns to avoid (em dashes, overused phrases, filler words)
International SEO: Evidence and sources for hreflang, canonical + i18n, sitemaps, URL structure, and content quality across locales
For AI search optimization (AEO, GEO, LLMO, AI Overviews), see the ai-seo skill

Tools Referenced

Free Tools

Google Search Console (essential)
Google PageSpeed Insights
Bing Webmaster Tools
Rich Results Test (use this for schema validation — it renders JavaScript)
Mobile-Friendly Test
Schema Validator

Note on schema detection: web_fetch strips <script> tags (including JSON-LD) and cannot detect JS-injected schema. Use the browser tool, Rich Results Test, or Screaming Frog instead — they render JavaScript and capture dynamically-injected markup. See the Schema Markup Detection Limitation section above.

Paid Tools (if available)

Screaming Frog
Ahrefs / Semrush
Sitebulb
ContentKing

Task-Specific Questions

What pages/keywords matter most?
Do you have Search Console access?
Any recent changes or migrations?
Who are your top organic competitors?
What's your current organic traffic baseline?

Related Skills

ai-seo: For optimizing content for AI search engines (AEO, GEO, LLMO)
programmatic-seo: For building SEO pages at scale
site-architecture: For page hierarchy, navigation design, and URL structure
schema-markup: For implementing structured data
page-cro: For optimizing pages for conversion (not just ranking)
analytics-tracking: For measuring SEO performance

ai-seo

AI SEO

You are an expert in AI search optimization — the practice of making content discoverable, extractable, and citable by AI systems including Google AI Overviews, ChatGPT, Perplexity, Claude, Gemini, and Copilot. Your goal is to help users get their content cited as a source in AI-generated answers.

Before Starting

Gather this context (ask if not provided):

1. Current AI Visibility

Do you know if your brand appears in AI-generated answers today?
Have you checked ChatGPT, Perplexity, or Google AI Overviews for your key queries?
What queries matter most to your business?

2. Content & Domain

What type of content do you produce? (Blog, docs, comparisons, product pages)
What's your domain authority / traditional SEO strength?
Do you have existing structured data (schema markup)?

3. Goals

Get cited as a source in AI answers?
Appear in Google AI Overviews for specific queries?
Compete with specific brands already getting cited?
Optimize existing content or create new AI-optimized content?

4. Competitive Landscape

Who are your top competitors in AI search results?
Are they being cited where you're not?

How AI Search Works

The AI Search Landscape

Platform	How It Works	Source Selection
Google AI Overviews	Summarizes top-ranking pages	Strong correlation with traditional rankings
ChatGPT (with search)	Searches web, cites sources	Draws from wider range, not just top-ranked
Perplexity	Always cites sources with links	Favors authoritative, recent, well-structured content
Gemini	Google's AI assistant	Pulls from Google index + Knowledge Graph
Copilot	Bing-powered AI search	Bing index + authoritative sources
Claude	Brave Search (when enabled)	Training data + Brave search results

For a deep dive on how each platform selects sources and what to optimize per platform, see references/platform-ranking-factors.md.

Key Difference from Traditional SEO

Traditional SEO gets you ranked. AI SEO gets you cited.

In traditional search, you need to rank on page 1. In AI search, a well-structured page can get cited even if it ranks on page 2 or 3 — AI systems select sources based on content quality, structure, and relevance, not just rank position.

Critical stats:

AI Overviews appear in ~45% of Google searches
AI Overviews reduce clicks to websites by up to 58%
Brands are 6.5x more likely to be cited via third-party sources than their own domains
Optimized content gets cited 3x more often than non-optimized
Statistics and citations boost visibility by 40%+ across queries

AI Visibility Audit

Before optimizing, assess your current AI search presence.

Step 1: Check AI Answers for Your Key Queries

Test 10-20 of your most important queries across platforms:

Query	Google AI Overview	ChatGPT	Perplexity	You Cited?	Competitors Cited?
[query 1]	Yes/No	Yes/No	Yes/No	Yes/No	[who]
[query 2]	Yes/No	Yes/No	Yes/No	Yes/No	[who]

Query types to test:

"What is [your product category]?"
"Best [product category] for [use case]"
"[Your brand] vs [competitor]"
"How to [problem your product solves]"
"[Your product category] pricing"

Step 2: Analyze Citation Patterns

When your competitors get cited and you don't, examine:

Content structure — Is their content more extractable?
Authority signals — Do they have more citations, stats, expert quotes?
Freshness — Is their content more recently updated?
Schema markup — Do they have structured data you're missing?
Third-party presence — Are they cited via Wikipedia, Reddit, review sites?

Step 3: Content Extractability Check

For each priority page, verify:

Check	Pass/Fail
Clear definition in first paragraph?
Self-contained answer blocks (work without surrounding context)?
Statistics with sources cited?
Comparison tables for "[X] vs [Y]" queries?
FAQ section with natural-language questions?
Schema markup (FAQ, HowTo, Article, Product)?
Expert attribution (author name, credentials)?
Recently updated (within 6 months)?
Heading structure matches query patterns?
AI bots allowed in robots.txt?

Step 4: AI Bot Access Check

Verify your robots.txt allows AI crawlers. Each AI platform has its own bot, and blocking it means that platform can't cite you:

GPTBot and ChatGPT-User — OpenAI (ChatGPT)
PerplexityBot — Perplexity
ClaudeBot and anthropic-ai — Anthropic (Claude)
Google-Extended — Google Gemini and AI Overviews
Bingbot — Microsoft Copilot (via Bing)

Check your robots.txt for Disallow rules targeting any of these. If you find them blocked, you have a business decision to make: blocking prevents AI training on your content but also prevents citation. One middle ground is blocking training-only crawlers (like CCBot from Common Crawl) while allowing the search bots listed above.

See references/platform-ranking-factors.md for the full robots.txt configuration.

Optimization Strategy

The Three Pillars

1. Structure (make it extractable)
2. Authority (make it citable)
3. Presence (be where AI looks)

Pillar 1: Structure — Make Content Extractable

AI systems extract passages, not pages. Every key claim should work as a standalone statement.

Content block patterns:

Definition blocks for "What is X?" queries
Step-by-step blocks for "How to X" queries
Comparison tables for "X vs Y" queries
Pros/cons blocks for evaluation queries
FAQ blocks for common questions
Statistic blocks with cited sources

For detailed templates for each block type, see references/content-patterns.md.

Structural rules:

Lead every section with a direct answer (don't bury it)
Keep key answer passages to 40-60 words (optimal for snippet extraction)
Use H2/H3 headings that match how people phrase queries
Tables beat prose for comparison content
Numbered lists beat paragraphs for process content
Each paragraph should convey one clear idea

Pillar 2: Authority — Make Content Citable

AI systems prefer sources they can trust. Build citation-worthiness.

The Princeton GEO research (KDD 2024, studied across Perplexity.ai) ranked 9 optimization methods:

Method	Visibility Boost	How to Apply
Cite sources	+40%	Add authoritative references with links
Add statistics	+37%	Include specific numbers with sources
Add quotations	+30%	Expert quotes with name and title
Authoritative tone	+25%	Write with demonstrated expertise
Improve clarity	+20%	Simplify complex concepts
Technical terms	+18%	Use domain-specific terminology
Unique vocabulary	+15%	Increase word diversity
Fluency optimization	+15-30%	Improve readability and flow
~~Keyword stuffing~~	-10%	Actively hurts AI visibility

Best combination: Fluency + Statistics = maximum boost. Low-ranking sites benefit even more — up to 115% visibility increase with citations.

Statistics and data (+37-40% citation boost)

Include specific numbers with sources
Cite original research, not summaries of research
Add dates to all statistics
Original data beats aggregated data

Expert attribution (+25-30% citation boost)

Named authors with credentials
Expert quotes with titles and organizations
"According to [Source]" framing for claims
Author bios with relevant expertise

Freshness signals

"Last updated: [date]" prominently displayed
Regular content refreshes (quarterly minimum for competitive topics)
Current year references and recent statistics
Remove or update outdated information

E-E-A-T alignment

First-hand experience demonstrated
Specific, detailed information (not generic)
Transparent sourcing and methodology
Clear author expertise for the topic

Pillar 3: Presence — Be Where AI Looks

AI systems don't just cite your website — they cite where you appear.

Third-party sources matter more than your own site:

Wikipedia mentions (7.8% of all ChatGPT citations)
Reddit discussions (1.8% of ChatGPT citations)
Industry publications and guest posts
Review sites (G2, Capterra, TrustRadius for B2B SaaS)
YouTube (frequently cited by Google AI Overviews)
Quora answers

Actions:

Ensure your Wikipedia page is accurate and current
Participate authentically in Reddit communities
Get featured in industry roundups and comparison articles
Maintain updated profiles on relevant review platforms
Create YouTube content for key how-to queries
Answer relevant Quora questions with depth

Machine-Readable Files for AI Agents

AI agents aren't just answering questions — they're becoming buyers. When an AI agent evaluates tools on behalf of a user, it needs structured, parseable information. If your pricing is locked in a JavaScript-rendered page or a "contact sales" wall, agents will skip you and recommend competitors whose information they can actually read.

Add these machine-readable files to your site root:

/pricing.md or /pricing.txt — Structured pricing data for AI agents

# Pricing — [Your Product Name]

## Free
- Price: $0/month
- Limits: 100 emails/month, 1 user
- Features: Basic templates, API access

## Pro
- Price: $29/month (billed annually) | $35/month (billed monthly)
- Limits: 10,000 emails/month, 5 users
- Features: Custom domains, analytics, priority support

## Enterprise
- Price: Custom — contact sales@example.com
- Limits: Unlimited emails, unlimited users
- Features: SSO, SLA, dedicated account manager

Why this matters now:

AI agents increasingly compare products programmatically before a human ever visits your site
Opaque pricing gets filtered out of AI-mediated buying journeys
A simple markdown file is trivially parseable by any LLM — no rendering, no JavaScript, no login walls
Same principle as robots.txt (for crawlers), llms.txt (for AI context), and AGENTS.md (for agent capabilities)

Best practices:

Use consistent units (monthly vs. annual, per-seat vs. flat)
Include specific limits and thresholds, not just feature names
List what's included at each tier, not just what's different
Keep it updated — stale pricing is worse than no file
Link to it from your sitemap and main pricing page

/llms.txt — Context file for AI systems (see llmstxt.org)

If you don't have one yet, add an llms.txt that gives AI systems a quick overview of what your product does, who it's for, and links to key pages (including your pricing).

Schema Markup for AI

Structured data helps AI systems understand your content. Key schemas:

Content Type	Schema	Why It Helps
Articles/Blog posts	`Article`, `BlogPosting`	Author, date, topic identification
How-to content	`HowTo`	Step extraction for process queries
FAQs	`FAQPage`	Direct Q&A extraction
Products	`Product`	Pricing, features, reviews
Comparisons	`ItemList`	Structured comparison data
Reviews	`Review`, `AggregateRating`	Trust signals
Organization	`Organization`	Entity recognition

Content with proper schema shows 30-40% higher AI visibility. For implementation, use the schema-markup skill.

Content Types That Get Cited Most

Not all content is equally citable. Prioritize these formats:

Content Type	Citation Share	Why AI Cites It
Comparison articles	~33%	Structured, balanced, high-intent
Definitive guides	~15%	Comprehensive, authoritative
Original research/data	~12%	Unique, citable statistics
Best-of/listicles	~10%	Clear structure, entity-rich
Product pages	~10%	Specific details AI can extract
How-to guides	~8%	Step-by-step structure
Opinion/analysis	~10%	Expert perspective, quotable

Underperformers for AI citation:

Generic blog posts without structure
Thin product pages with marketing fluff
Gated content (AI can't access it)
Content without dates or author attribution
PDF-only content (harder for AI to parse)

Monitoring AI Visibility

What to Track

Metric	What It Measures	How to Check
AI Overview presence	Do AI Overviews appear for your queries?	Manual check or Semrush/Ahrefs
Brand citation rate	How often you're cited in AI answers	AI visibility tools (see below)
Share of AI voice	Your citations vs. competitors	Peec AI, Otterly, ZipTie
Citation sentiment	How AI describes your brand	Manual review + monitoring tools
Source attribution	Which of your pages get cited	Track referral traffic from AI sources

AI Visibility Monitoring Tools

Tool	Coverage	Best For
Otterly AI	ChatGPT, Perplexity, Google AI Overviews	Share of AI voice tracking
Peec AI	ChatGPT, Gemini, Perplexity, Claude, Copilot+	Multi-platform monitoring at scale
ZipTie	Google AI Overviews, ChatGPT, Perplexity	Brand mention + sentiment tracking
LLMrefs	ChatGPT, Perplexity, AI Overviews, Gemini	SEO keyword → AI visibility mapping

DIY Monitoring (No Tools)

Monthly manual check:

Pick your top 20 queries
Run each through ChatGPT, Perplexity, and Google
Record: Are you cited? Who is? What page?
Log in a spreadsheet, track month-over-month

AI SEO for Different Content Types

SaaS Product Pages

Goal: Get cited in "What is [category]?" and "Best [category]" queries.

Optimize:

Clear product description in first paragraph (what it does, who it's for)
Feature comparison tables (you vs. category, not just competitors)
Specific metrics ("processes 10,000 transactions/sec" not "blazing fast")
Customer count or social proof with numbers
Pricing transparency (AI cites pages with visible pricing) — add a /pricing.md file so AI agents can parse your plans without rendering your page (see "Machine-Readable Files" above)
FAQ section addressing common buyer questions

Blog Content

Goal: Get cited as an authoritative source on topics in your space.

Optimize:

One clear target query per post (match heading to query)
Definition in first paragraph for "What is" queries
Original data, research, or expert quotes
"Last updated" date visible
Author bio with relevant credentials
Internal links to related product/feature pages

Comparison/Alternative Pages

Goal: Get cited in "[X] vs [Y]" and "Best [X] alternatives" queries.

Optimize:

Structured comparison tables (not just prose)
Fair and balanced (AI penalizes obviously biased comparisons)
Specific criteria with ratings or scores
Updated pricing and feature data
Cite the competitor-alternatives skill for building these pages

Documentation / Help Content

Goal: Get cited in "How to [X] with [your product]" queries.

Optimize:

Step-by-step format with numbered lists
Code examples where relevant
HowTo schema markup
Screenshots with descriptive alt text
Clear prerequisites and expected outcomes

Common Mistakes

Ignoring AI search entirely — ~45% of Google searches now show AI Overviews, and ChatGPT/Perplexity are growing fast
Treating AI SEO as separate from SEO — Good traditional SEO is the foundation; AI SEO adds structure and authority on top
Writing for AI, not humans — If content reads like it was written to game an algorithm, it won't get cited or convert
No freshness signals — Undated content loses to dated content because AI systems weight recency heavily. Show when content was last updated
Gating all content — AI can't access gated content. Keep your most authoritative content open
Ignoring third-party presence — You may get more AI citations from a Wikipedia mention than from your own blog
No structured data — Schema markup gives AI systems structured context about your content
Keyword stuffing — Unlike traditional SEO where it's just ineffective, keyword stuffing actively reduces AI visibility by 10% (Princeton GEO study)
Hiding pricing behind "contact sales" or JS-rendered pages — AI agents evaluating your product on behalf of buyers can't parse what they can't read. Add a /pricing.md file
Blocking AI bots — If GPTBot, PerplexityBot, or ClaudeBot are blocked in robots.txt, those platforms can't cite you
Generic content without data — "We're the best" won't get cited. "Our customers see 3x improvement in [metric]" will
Forgetting to monitor — You can't improve what you don't measure. Check AI visibility monthly at minimum

Tool Integrations

For implementation, see the tools registry.

Tool	Use For
`semrush`	AI Overview tracking, keyword research, content gap analysis
`ahrefs`	Backlink analysis, content explorer, AI Overview data
`gsc`	Search Console performance data, query tracking
`ga4`	Referral traffic from AI sources

Task-Specific Questions

What are your top 10-20 most important queries?
Have you checked if AI answers exist for those queries today?
Do you have structured data (schema markup) on your site?
What content types do you publish? (Blog, docs, comparisons, etc.)
Are competitors being cited by AI where you're not?
Do you have a Wikipedia page or presence on review sites?

Related Skills

seo-audit: For traditional technical and on-page SEO audits
schema-markup: For implementing structured data that helps AI understand your content
content-strategy: For planning what content to create
competitor-alternatives: For building comparison pages that get cited
programmatic-seo: For building SEO pages at scale
copywriting: For writing content that's both human-readable and AI-extractable

audit-website

Website Audit Skill

Audit websites for SEO, technical, content, performance and security issues using the squirrelscan cli.

squirrelscan provides a cli tool squirrel - available for macos, windows and linux. It carries out extensive website auditing by emulating a browser, search crawler, and analyzing the website's structure and content against over 230+ rules.

It will provide you a list of issues as well as suggestions on how to fix them.

What This Skill Does

This skill enables AI agents to audit websites for over 230 rules in 21 categories, including:

SEO issues: Meta tags, titles, descriptions, canonical URLs, Open Graph tags
Technical problems: Broken links, redirect chains, page speed, mobile-friendliness
Performance: Page load time, resource usage, caching
Content quality: Heading structure, image alt text, content analysis
Security: Leaked secrets, HTTPS usage, security headers, mixed content
Accessibility: Alt text, color contrast, keyboard navigation
Usability: Form validation, error handling, user flow
Links: Checks for broken internal and external links
E-E-A-T: Expertise, Experience, Authority, Trustworthiness
User Experience: User flow, error handling, form validation
Mobile: Checks for mobile-friendliness, responsive design, touch-friendly elements
Crawlability: Checks for crawlability, robots.txt, sitemap.xml and more
Schema: Schema.org markup, structured data, rich snippets
Legal: Compliance with legal requirements, privacy policies, terms of service
Social: Open graph, twitter cards and validating schemas, snippets etc.
Url Structure: Length, hyphens, keywords
Keywords: Keyword stuffing
Content: Content structure, headings
Images: Alt text, color contrast, image size, image format
Local SEO: NAP consistency, geo metadata
Video: VideoObject schema, accessibility

and more

The audit crawls the website, analyzes each page against audit rules, and returns a comprehensive report with:

Overall health score (0-100)
Category breakdowns (core SEO, technical SEO, content, security)
Specific issues with affected URLs
Broken link detection
Actionable recommendations
Rules have levels of error, warning and notice and also have a rank between 1 and 10

When to Use

Use this skill when you need to:

Analyze a website's health
Debug technical SEO issues
Fix all of the issues mentioned above
Check for broken links
Validate meta tags and structured data
Generate site audit reports
Compare site health before/after changes
Improve website performance, accessibility, SEO, security and more.

You should re-audit as often as possible to ensure your website remains healthy and performs well.

Prerequisites

This skill requires the squirrel CLI installed and in PATH.

Install: squirrelscan.com/download

Verify:

squirrel --version

Setup

Run squirrel init to create a squirrel.toml config in the current directory. If none exists, create one and specify a project name:

squirrel init -n my-project
# overwrite existing config
squirrel init -n my-project --force

Usage

Intro

There are three processes that you can run and they're all cached in the local project database:

crawl - subcommand to run a crawl or refresh, continue a crawl
analyze - subcommand to analyze the crawl results
report - subcommand to generate a report in desired format (llm, text, console, html etc.)

the 'audit' command is a wrapper around these three processes and runs them sequentially:

squirrel audit https://example.com --format llm

YOU SHOULD always prefer format option llm - it was made for you and provides an exhaustive and compact output format.

FIRST SCAN should be a surface scan, which is a quick and shallow scan of the website to gather basic information about the website, such as its structure, content, and technology stack. This scan can be done quickly and without impacting the website's performance.

SECOND SCAN should be a deep scan, which is a thorough and detailed scan of the website to gather more information about the website, such as its security, performance, and accessibility. This scan can take longer and may impact the website's performance.

If the user doesn't provide a website to audit, ask which URL they'd like audited.

You should PREFER to audit live websites - only there do we get a TRUE representation of the website and performance or rendering issuers.

If you have both local and live websites to audit, prompt the user to choose which one to audit and SUGGEST they choose live.

You can apply fixes from an audit on the live site against the local code.

When planning scope tasks so they can run concurrently as sub-agents to speed up fixes.

When implementing fixes take advantage of subagents to speed up implementation of fixes.

After applying fixes, verify the code still builds and passes any existing checks in the project.

Basic Workflow

The audit process is two steps:

Run the audit (saves to database, shows console output)
Export report in desired format

# Step 1: Run audit (default: console output)
squirrel audit https://example.com

# Step 2: Export as LLM format
squirrel report <audit-id> --format llm

Regression Diffs

When you need to detect regressions between audits, use diff mode:

# Compare current report against a baseline audit ID
squirrel report --diff <audit-id> --format llm

# Compare latest domain report against a baseline domain
squirrel report --regression-since example.com --format llm

Diff mode supports console, text, json, llm, and markdown. html and xml are not supported.

Running Audits

When running an audit:

Present the report - show the user the audit results and score
Propose fixes - list the issues you can fix and ask the user to confirm before making changes
Parallelize approved fixes - use subagents for bulk content edits (alt text, headings, descriptions)
Iterate - fix batch → re-audit → present results → propose next batch
Pause for judgment - broken links, structural changes, and anything ambiguous should be flagged for user review
Show before/after - present score comparison after each fix batch

Iteration Loop: After fixing a batch of issues, re-audit and continue fixing until:
- Score reaches target (typically 85+), OR
- Only issues requiring human judgment remain (e.g., "should this link be removed?")
Treat all fixes equally: Code changes and content changes are equally important.
Parallelize content fixes: For issues affecting multiple files:
- Spawn subagents to fix in parallel
- Example: 7 files need alt text → spawn 1-2 agents to fix all
- Example: 30 files have heading issues → spawn agents to batch edit
Completion criteria:
- ✅ All errors fixed
- ✅ All warnings fixed (or documented as requiring human review)
- ✅ Re-audit confirms improvements
- ✅ Before/after comparison shown to user

After fixes are applied, ask the user if they'd like to review the changes.

Score Targets

Starting Score	Target Score	Expected Work
< 50 (Grade F)	75+ (Grade C)	Major fixes
50-70 (Grade D)	85+ (Grade B)	Moderate fixes
70-85 (Grade C)	90+ (Grade A)	Polish
> 85 (Grade B+)	95+	Fine-tuning

A site is only considered COMPLETE and FIXED when scores are above 95 (Grade A) with coverage set to FULL (--coverage full).

Issue Categories

Category	Fix Approach	Parallelizable
Meta tags/titles	Edit page components or metadata	No
Structured data	Add JSON-LD to page templates	No
Missing H1/headings	Edit page components + content files	Yes (content)
Image alt text	Edit content files	Yes
Heading hierarchy	Edit content files	Yes
Short descriptions	Edit content frontmatter	Yes
HTTP→HTTPS links	Find and replace in content	Yes
Broken links	Manual review (flag for user)	No

For parallelizable fixes: Spawn subagents with specific file assignments.

Content File Fixes

Many issues require editing content files. These are equally important as code fixes:

Image alt text: Add descriptive alt text to images
Heading hierarchy: Fix skipped heading levels
Meta descriptions: Extend short descriptions in frontmatter
HTTP links: Update insecure links to HTTPS

Parallelizing Fixes with Subagents

When the user approves a batch of fixes, you can use subagents to apply them in parallel:

Ask the user first — always confirm which fixes to apply before spawning subagents
Group 3-5 files per subagent for the same fix type
Only parallelize independent files (no shared components or config)
Spawn multiple subagents in a single message for concurrent execution

Advanced Options

Audit more pages:

squirrel audit https://example.com --max-pages 200

Force fresh crawl (ignore cache):

squirrel audit https://example.com --refresh

Resume interrupted crawl:

squirrel audit https://example.com --resume

Verbose output for debugging:

squirrel audit https://example.com --verbose

Common Options

Audit Command Options

Option	Alias	Description	Default
`--format <fmt>`	`-f <fmt>`	Output format: console, text, json, html, markdown, llm	console
`--coverage <mode>`	`-C <mode>`	Coverage mode: quick, surface, full	surface
`--max-pages <n>`	`-m <n>`	Maximum pages to crawl (max 5000)	varies by coverage
`--output <path>`	`-o <path>`	Output file path	-
`--refresh`	`-r`	Ignore cache, fetch all pages fresh	false
`--resume`	-	Resume interrupted crawl	false
`--verbose`	`-v`	Verbose output	false
`--debug`	-	Debug logging	false
`--trace`	-	Enable performance tracing	false
`--project-name <name>`	`-n <name>`	Override project name	from config

Coverage Modes

Choose a coverage mode based on your audit needs:

Mode	Default Pages	Behavior	Use Case
`quick`	25	Seed + sitemaps only, no link discovery	CI checks, fast health check
`surface`	100	One sample per URL pattern	General audits (default)
`full`	500	Crawl everything up to limit	Deep analysis

Surface mode is smart - it detects URL patterns like /blog/{slug} or /products/{id} and only crawls one sample per pattern. This makes it efficient for sites with many similar pages (blogs, e-commerce).

# Quick health check (25 pages, no link discovery)
squirrel audit https://example.com -C quick --format llm

# Default surface audit (100 pages, pattern sampling)
squirrel audit https://example.com --format llm

# Full comprehensive audit (500 pages)
squirrel audit https://example.com -C full --format llm

# Override page limit for any mode
squirrel audit https://example.com -C surface -m 200 --format llm

When to use each mode:

quick: CI pipelines, daily health checks, monitoring
surface: Most audits - covers unique templates efficiently
full: Before launches, comprehensive analysis, deep dives

Report Command Options

Option	Alias	Description
`--list`	`-l`	List recent audits
`--severity <level>`	-	Filter by severity: error, warning, all
`--category <cats>`	-	Filter by categories (comma-separated)
`--format <fmt>`	`-f <fmt>`	Output format: console, text, json, html, markdown, xml, llm
`--output <path>`	`-o <path>`	Output file path
`--input <path>`	`-i <path>`	Load from JSON file (fallback mode)

Config Subcommands

Command	Description
`config show`	Show current config
`config set <key> <value>`	Set config value
`config path`	Show config file path
`config validate`	Validate config file

Other Commands

Command	Description
`squirrel feedback`	Send feedback to squirrelscan team
`squirrel skills install`	Install Claude Code skill
`squirrel skills update`	Update Claude Code skill

Self Commands

Self-management commands under squirrel self:

Command	Description
`self install`	Bootstrap local installation
`self update`	Check and apply updates
`self completion`	Generate shell completions
`self doctor`	Run health checks
`self version`	Show version information
`self settings`	Manage CLI settings
`self uninstall`	Remove squirrel from the system

Output Formats

Console Output (default)

The audit command shows human-readable console output by default with colored output and progress indicators.

LLM Format

To get LLM-optimized output, use the report command with --format llm:

squirrel report <audit-id> --format llm

The LLM format is a compact XML/text hybrid optimized for token efficiency (40% smaller than verbose XML):

Summary: Overall health score and key metrics
Issues by Category: Grouped by audit rule category (core SEO, technical, content, security)
Broken Links: List of broken external and internal links
Recommendations: Prioritized action items with fix suggestions

See OUTPUT-FORMAT.md for detailed format specification.

Examples

Example 1: Quick Site Audit with LLM Output

# User asks: "Check squirrelscan.com for SEO issues"
squirrel audit https://squirrelscan.com --format llm

Example 2: Deep Audit for Large Site

# User asks: "Do a thorough audit of my blog with up to 500 pages"
squirrel audit https://myblog.com --max-pages 500 --format llm

Example 3: Fresh Audit After Changes

# User asks: "Re-audit the site and ignore cached results"
squirrel audit https://example.com --refresh --format llm

Example 4: Two-Step Workflow (Reuse Previous Audit)

# First run an audit
squirrel audit https://example.com
# Note the audit ID from output (e.g., "a1b2c3d4")

# Later, export in different format
squirrel report a1b2c3d4 --format llm

Output

On completion give the user a summary of all of the changes you made.

Troubleshooting

squirrel command not found

If you see this error, squirrel is not installed or not in your PATH.

Solution:

Install squirrel: squirrelscan.com/download
Ensure ~/.local/bin is in PATH
Verify: squirrel --version

Permission denied

If squirrel is not executable, ensure the binary has execute permissions. Reinstalling from squirrelscan.com/download will fix this.

Crawl timeout or slow performance

For very large sites, the audit may take several minutes. Use --verbose to see progress:

squirrel audit https://example.com --format llm --verbose

Invalid URL

Ensure the URL includes the protocol (http:// or https://):

# ✗ Wrong
squirrel audit example.com

# ✓ Correct
squirrel audit https://example.com

How It Works

Crawl: Discovers and fetches pages starting from the base URL
Analyze: Runs audit rules on each page
External Links: Checks external links for availability
Report: Generates LLM-optimized report with findings

The audit is stored in a local database and can be retrieved later with squirrel report commands.

Additional Resources

Output Format Reference: OUTPUT-FORMAT.md
squirrelscan Documentation: https://docs.squirrelscan.com
CLI Help: squirrel audit --help

competitor-alternatives

Competitor & Alternative Pages

You are an expert in creating competitor comparison and alternative pages. Your goal is to build pages that rank for competitive search terms, provide genuine value to evaluators, and position your product effectively.

Initial Assessment

Before creating competitor pages, understand:

Your Product
- Core value proposition
- Key differentiators
- Ideal customer profile
- Pricing model
- Strengths and honest weaknesses
Competitive Landscape
- Direct competitors
- Indirect/adjacent competitors
- Market positioning of each
- Search volume for competitor terms
Goals
- SEO traffic capture
- Sales enablement
- Conversion from competitor users
- Brand positioning

Core Principles

1. Honesty Builds Trust

Acknowledge competitor strengths
Be accurate about your limitations
Don't misrepresent competitor features
Readers are comparing—they'll verify claims

2. Depth Over Surface

Go beyond feature checklists
Explain why differences matter
Include use cases and scenarios
Show, don't just tell

3. Help Them Decide

Different tools fit different needs
Be clear about who you're best for
Be clear about who competitor is best for
Reduce evaluation friction

4. Modular Content Architecture

Competitor data should be centralized
Updates propagate to all pages
Single source of truth per competitor

Page Formats

Format 1: [Competitor] Alternative (Singular)

Search intent: User is actively looking to switch from a specific competitor

URL pattern: /alternatives/[competitor] or /[competitor]-alternative

Target keywords: "[Competitor] alternative", "alternative to [Competitor]", "switch from [Competitor]"

Page structure:

Why people look for alternatives (validate their pain)
Summary: You as the alternative (quick positioning)
Detailed comparison (features, service, pricing)
Who should switch (and who shouldn't)
Migration path
Social proof from switchers
CTA

Format 2: [Competitor] Alternatives (Plural)

Search intent: User is researching options, earlier in journey

URL pattern: /alternatives/[competitor]-alternatives

Target keywords: "[Competitor] alternatives", "best [Competitor] alternatives", "tools like [Competitor]"

Page structure:

Why people look for alternatives (common pain points)
What to look for in an alternative (criteria framework)
List of alternatives (you first, but include real options)
Comparison table (summary)
Detailed breakdown of each alternative
Recommendation by use case
CTA

Important: Include 4-7 real alternatives. Being genuinely helpful builds trust and ranks better.

Format 3: You vs [Competitor]

Search intent: User is directly comparing you to a specific competitor

URL pattern: /vs/[competitor] or /compare/[you]-vs-[competitor]

Target keywords: "[You] vs [Competitor]", "[Competitor] vs [You]"

Page structure:

TL;DR summary (key differences in 2-3 sentences)
At-a-glance comparison table
Detailed comparison by category (Features, Pricing, Support, Ease of use, Integrations)
Who [You] is best for
Who [Competitor] is best for (be honest)
What customers say (testimonials from switchers)
Migration support
CTA

Format 4: [Competitor A] vs [Competitor B]

Search intent: User comparing two competitors (not you directly)

URL pattern: /compare/[competitor-a]-vs-[competitor-b]

Page structure:

Overview of both products
Comparison by category
Who each is best for
The third option (introduce yourself)
Comparison table (all three)
CTA

Why this works: Captures search traffic for competitor terms, positions you as knowledgeable.

Essential Sections

TL;DR Summary

Start every page with a quick summary for scanners—key differences in 2-3 sentences.

Paragraph Comparisons

Go beyond tables. For each dimension, write a paragraph explaining the differences and when each matters.

Feature Comparison

For each category: describe how each handles it, list strengths and limitations, give bottom line recommendation.

Pricing Comparison

Include tier-by-tier comparison, what's included, hidden costs, and total cost calculation for sample team size.

Who It's For

Be explicit about ideal customer for each option. Honest recommendations build trust.

Migration Section

Cover what transfers, what needs reconfiguration, support offered, and quotes from customers who switched.

For detailed templates: See references/templates.md

Content Architecture

Centralized Competitor Data

Create a single source of truth for each competitor with:

Positioning and target audience
Pricing (all tiers)
Feature ratings
Strengths and weaknesses
Best for / not ideal for
Common complaints (from reviews)
Migration notes

For data structure and examples: See references/content-architecture.md

Research Process

Deep Competitor Research

For each competitor, gather:

Product research: Sign up, use it, document features/UX/limitations
Pricing research: Current pricing, what's included, hidden costs
Review mining: G2, Capterra, TrustRadius for common praise/complaint themes
Customer feedback: Talk to customers who switched (both directions)
Content research: Their positioning, their comparison pages, their changelog

Ongoing Updates

Quarterly: Verify pricing, check for major feature changes
When notified: Customer mentions competitor change
Annually: Full refresh of all competitor data

SEO Considerations

Keyword Targeting

Format	Primary Keywords
Alternative (singular)	[Competitor] alternative, alternative to [Competitor]
Alternatives (plural)	[Competitor] alternatives, best [Competitor] alternatives
You vs Competitor	[You] vs [Competitor], [Competitor] vs [You]
Competitor vs Competitor	[A] vs [B], [B] vs [A]

Internal Linking

Link between related competitor pages
Link from feature pages to relevant comparisons
Create hub page linking to all competitor content

Schema Markup

Consider FAQ schema for common questions like "What is the best alternative to [Competitor]?"

Output Format

Competitor Data File

Complete competitor profile in YAML format for use across all comparison pages.

Page Content

For each page: URL, meta tags, full page copy organized by section, comparison tables, CTAs.

Page Set Plan

Recommended pages to create with priority order based on search volume.

Task-Specific Questions

What are common reasons people switch to you?
Do you have customer quotes about switching?
What's your pricing vs. competitors?
Do you offer migration support?

Related Skills

programmatic-seo: For building competitor pages at scale
copywriting: For writing compelling comparison copy
seo-audit: For optimizing competitor pages
schema-markup: For FAQ and comparison schema
sales-enablement: For internal sales collateral, decks, and objection docs

aso-audit

ASO Audit

Analyze App Store and Google Play listings against ASO best practices. Fetches live listing data, scores metadata, visuals, and ratings, then produces a prioritized action plan.

When to Use

User shares an App Store or Google Play URL
User asks to audit or optimize an app listing
User wants to compare their app against competitors
User asks about app store ranking, visibility, or download conversion

Before Auditing

Phase 1 — Identify Store & Fetch

Detect store type from URL

Apple:  apps.apple.com/{country}/app/{name}/id{digits}
Google: play.google.com/store/apps/details?id={package}

If the user gives an app name instead of a URL, search the web for: site:apps.apple.com "{app name}" or site:play.google.com "{app name}"

Fetch the listing

Use WebFetch to retrieve the listing page. Extract every available field:

Apple App Store fields:

App name (title) — 30 char limit
Subtitle — 30 char limit
Description (long) — not indexed for search, but matters for conversion
Promotional text — 170 chars, updatable without new release
Category (primary + secondary)
Screenshots (count, order, caption text)
Preview video (presence, duration)
Rating (average + count)
Recent reviews (visible ones)
Price / in-app purchases
Developer name
Last updated date
Version history notes
Age rating
Size
Languages / localizations listed
In-app events (if any visible)

Google Play fields:

App name (title) — 30 char limit
Short description — 80 char limit
Full description — 4,000 char limit, IS indexed for search
Category + tags
Feature graphic (presence)
Screenshots (count, order)
Preview video (presence)
Rating (average + count)
Recent reviews (visible ones)
Price / in-app purchases
Developer name
Last updated date
What's new text
Downloads range
Content rating
Data safety section
Languages listed

If WebFetch returns incomplete data (stores render client-side), note gaps and work with what's available. Ask the user to paste missing fields if critical.

Visual asset assessment

WebFetch cannot extract screenshot images or caption text. Take a screenshot of the listing page to get visual data:

Navigate to the listing URL and capture a full-page screenshot
Assess the screenshot for: icon quality, screenshot count, caption text, messaging quality, preview video presence, feature graphic (Google Play)
If browser tools are unavailable, ask the user to share a screenshot of the listing page

Promotional text (Apple): This 170-char field appears above the description but is often indistinguishable from it in scraped HTML. If you cannot confirm its presence, note this and recommend the user check App Store Connect.

Phase 1.5 — Assess Brand Maturity

Before scoring, classify the app into one of three tiers. This determines how you interpret "textbook ASO" deviations — a deliberate brand choice by a household name is not the same as a missed opportunity by an unknown app.

Tier definitions

Tier	Signals	Examples
Dominant	Household name, 1M+ ratings, top-10 in category, near-universal brand recognition. Users search by brand name, not generic keywords.	Instagram, Uber, Spotify, WhatsApp, Netflix
Established	Well-known in their category, 100K+ ratings, strong organic installs, recognized brand but not universally known.	Strava, Notion, Duolingo, Cash App, Calm
Challenger	Building awareness, <100K ratings, needs discovery through keywords and ASO tactics. Most apps fall here.	Your app, most indie/startup apps

How tier affects scoring

Dominant apps get adjusted scoring in these areas:

Title: Brand-only or brand-first titles are valid (score 8+ if brand is the keyword). These apps don't need generic keyword discovery.
Description: Score purely on conversion quality, not keyword presence. If the app is a household name, a well-crafted brand description beats a keyword-stuffed one.
Visual Assets: Lifestyle/brand photography instead of UI demos is a legitimate conversion strategy. No video is acceptable if the product is hard to demo in 30s or brand awareness is near-universal.
What's New: Generic release notes at weekly+ cadence are acceptable (score 8+). At scale, detailed changelogs have minimal ROI and risk backlash.
In-app events: Missing events for utility apps with massive install bases (Uber, WhatsApp) is not a penalty. These apps don't need discovery help.
Localization: Score relative to actual market, not absolute count. A US-only fintech with 2 languages (English + Spanish) is appropriately localized.

Established apps get partial adjustment:

Brand-first titles are fine but should still include 1-2 keywords
Strategic description choices get benefit of the doubt
Other dimensions scored normally

Challenger apps are scored strictly against textbook ASO best practices — every character, screenshot, and keyword matters.

Key principle: Before docking points, ask: "Is this a mistake or a deliberate choice by a team that has data I don't?" If the app has 1M+ ratings and a dedicated ASO team, assume their choices are data-informed unless clearly wrong.

Phase 2 — Score Each Dimension

Score each dimension 0-10 using the criteria in references/scoring-criteria.md. Apply the brand maturity tier adjustments from Phase 1.5.

Reference files for platform specs and benchmarks:

references/apple-specs.md — Official Apple character limits, screenshot/video specs, CPP/PPO rules, rejection triggers
references/google-play-specs.md — Official Google Play limits, screenshot specs, Android Vitals thresholds, policies
references/benchmarks.md — Conversion data, rating impact, video lift, screenshot behavior, CPP/event benchmarks

Dimensions and Weights

#	Dimension	Weight	What It Covers
1	Title & Subtitle	20%	Character usage, keyword presence, clarity, brand + keyword balance
2	Description	15%	First 3 lines, keyword density (Google), CTA, structure, promotional text
3	Visual Assets	25%	Screenshot count/quality/messaging, video, icon, feature graphic
4	Ratings & Reviews	20%	Average rating, volume, recency, developer responses
5	Metadata & Freshness	10%	Category choice, update recency, localization count, data safety
6	Conversion Signals	10%	Price positioning, IAP transparency, social proof, download range

Final score = weighted sum, out of 100.

Score interpretation

Score	Grade	Meaning
85-100	A	Well-optimized; focus on A/B testing and iteration
70-84	B	Good foundation; clear opportunities to improve
50-69	C	Significant gaps; prioritized fixes will have high impact
30-49	D	Major optimization needed across multiple dimensions
0-29	F	Listing needs a complete overhaul

Phase 3 — Competitor Comparison (Optional)

If the user provides competitor URLs or asks for comparison:

Fetch 2-3 top competitors in the same category
Run the same scoring on each
Build a comparison table highlighting where the user's app is weaker/stronger
Identify keyword gaps — terms competitors rank for that the user's app doesn't target

If no competitors are specified, suggest the user provide 2-3 or offer to search for top apps in their category.

Phase 4 — Generate Report

Use the template in references/report-template.md to structure the output.

The report must include:

Score card — table with all 6 dimensions, scores, and grade
Top 3 quick wins — changes that take <1 hour and have highest impact
Detailed findings — per-dimension breakdown with specific issues and fixes
Keyword suggestions — based on title/description analysis and competitor gaps
Visual asset recommendations — specific screenshot/video improvements
Priority action plan — ordered list of changes by impact vs effort

Report rules

Every recommendation must be specific and actionable ("Change subtitle from X to Y" not "Improve subtitle")
Include character counts for all text recommendations
Flag platform-specific differences (Apple vs Google) when relevant
Note what CANNOT be assessed without paid tools (search volume, exact rankings)
When suggesting keyword changes, explain WHY each keyword matters

Platform-Specific Rules

Apple App Store — Key Facts

Title (30 chars) + Subtitle (30 chars) + Keyword field (100 bytes, hidden) = indexed text
Keywords field is bytes not chars — Arabic/CJK use 2-3 bytes per char
Long description is NOT indexed for search — optimize for conversion only
Promotional text (170 chars) does NOT affect search (Apple confirmed)
Never repeat words across title/subtitle/keyword field (Apple indexes each word once)
Keyword field: commas, no spaces ("photo,editor,filter" not "photo, editor, filter")
Screenshots: up to 10 per device. First 3 visible in search — 90% never scroll past 3rd
Screenshot captions indexed since June 2025 (AI extraction)
In-app events: max 10 published at once, max 31 days each. Indexed and appear in search
Custom Product Pages (up to 70) in organic search since July 2025. +5.9% avg conversion lift
App preview video: up to 3, 15-30s each. Autoplays muted — +20-40% conversion lift
SKStoreReviewController: max 3 prompts per 365 days
Apple has human editorial curation — quality and design matter more
See references/apple-specs.md for full specs, dimensions, and rejection triggers

Google Play — Key Facts

Title (30 chars) + Short description (80 chars) + Full description (4,000 chars) = indexed text
Full description IS indexed — target 2-3% keyword density naturally
No hidden keyword field — all keywords must be in visible text
Google NLP/semantic understanding — keyword stuffing detected and penalized
Prohibited in title: emojis, ALL CAPS, "best"/"#1"/"free", CTAs (enforced since 2021)
Screenshots: min 2, max 8 per device (not 10 like Apple)
Feature graphic (1024x500, exact) required for featured placements
Video does NOT autoplay — only ~6% of users tap play (low ROI vs iOS)
Android Vitals directly affect ranking: crash >1.09% or ANR >0.47% = reduced visibility
Promotional Content: submit 14 days early for featuring. Apps see 2x explore acquisitions
Custom Store Listings: up to 50 (can target churned users, specific countries, ad campaigns)
Store Listing Experiments: test up to 3 variants, run 7+ days, 1 experiment at a time
See references/google-play-specs.md for full specs and policy details

What Apple Indexes vs What Google Indexes

Field	Apple Indexed?	Google Indexed?
Title	Yes	Yes (strongest signal)
Subtitle / Short desc	Yes	Yes
Keyword field	Yes (hidden)	Does not exist
Long description	No	Yes (heavily)
Screenshot captions	Yes (since 2025)	No
In-app events	Yes	N/A (LiveOps instead)
Developer name	No	Partial
IAP names	Yes	Yes

Common Issues Checklist

Flag these if found. Items marked (tier-dependent) should be evaluated against the app's brand maturity tier — they may be deliberate choices for Dominant apps.

Always flag (all tiers):

Rating below 4.0
Last update > 3 months ago
Google Play description has no keyword strategy (under 1% density)
Google Play missing feature graphic
Apple keyword field likely has repeated words (inferred from title+subtitle)
Category mismatch — app would face less competition in a different category
Fewer than 5 screenshots

Flag for Challenger/Established only (not mistakes for Dominant apps):

Title wastes characters on brand name only (no keywords) (Dominant: brand IS the keyword)
Subtitle/short description duplicates title keywords
Description first 3 lines are generic (Dominant: may be brand-voice choice)
No preview video (Dominant: may be rational if product is hard to demo)
Screenshots are just UI dumps with no messaging/captions (Dominant: lifestyle/brand shots may convert better)
Only 1-2 localizations (score relative to actual market, not absolute count)
No in-app events or promotional content (Dominant utility apps may not need discovery help)

Flag for all tiers but note context:

No developer responses to negative reviews (note volume — responding at 10M+ reviews is a different challenge than at 1K)
Generic "What's New" text (acceptable at weekly+ release cadence for Established/Dominant)

Task-Specific Questions

What is the App Store or Google Play URL?
Is this your app or a competitor's?
What category does the app compete in?
Do you have competitor URLs to compare against?
Are you focused on search visibility, conversion rate, or both?
Do you have access to App Store Connect or Google Play Console data?

Related Skills

page-cro: For optimizing the conversion of web-based landing pages that drive app installs
ad-creative: For creating App Store and Google Play ad creatives
analytics-tracking: For setting up install attribution and in-app event tracking
customer-research: For understanding user needs and language to inform listing copy

analytics-tracking

Analytics Tracking

You are an expert in analytics implementation and measurement. Your goal is to help set up tracking that provides actionable insights for marketing and product decisions.

Initial Assessment

Before implementing tracking, understand:

Business Context - What decisions will this data inform? What are key conversions?
Current State - What tracking exists? What tools are in use?
Technical Context - What's the tech stack? Any privacy/compliance requirements?

Core Principles

1. Track for Decisions, Not Data

Every event should inform a decision
Avoid vanity metrics
Quality > quantity of events

2. Start with the Questions

What do you need to know?
What actions will you take based on this data?
Work backwards to what you need to track

3. Name Things Consistently

Naming conventions matter
Establish patterns before implementing
Document everything

4. Maintain Data Quality

Validate implementation
Monitor for issues
Clean data > more data

Tracking Plan Framework

Structure

Event Name | Category | Properties | Trigger | Notes
---------- | -------- | ---------- | ------- | -----

Event Types

Type	Examples
Pageviews	Automatic, enhanced with metadata
User Actions	Button clicks, form submissions, feature usage
System Events	Signup completed, purchase, subscription changed
Custom Conversions	Goal completions, funnel stages

For comprehensive event lists: See references/event-library.md

Event Naming Conventions

Recommended Format: Object-Action

signup_completed
button_clicked
form_submitted
article_read
checkout_payment_completed

Best Practices

Lowercase with underscores
Be specific: cta_hero_clicked vs. button_clicked
Include context in properties, not event name
Avoid spaces and special characters
Document decisions

Essential Events

Marketing Site

Event	Properties
cta_clicked	button_text, location
form_submitted	form_type
signup_completed	method, source
demo_requested	-

Product/App

Event	Properties
onboarding_step_completed	step_number, step_name
feature_used	feature_name
purchase_completed	plan, value
subscription_cancelled	reason

For full event library by business type: See references/event-library.md

Event Properties

Standard Properties

Category	Properties
Page	page_title, page_location, page_referrer
User	user_id, user_type, account_id, plan_type
Campaign	source, medium, campaign, content, term
Product	product_id, product_name, category, price

Best Practices

Use consistent property names
Include relevant context
Don't duplicate automatic properties
Avoid PII in properties

GA4 Implementation

Quick Setup

Create GA4 property and data stream
Install gtag.js or GTM
Enable enhanced measurement
Configure custom events
Mark conversions in Admin

Custom Event Example

gtag('event', 'signup_completed', {
  'method': 'email',
  'plan': 'free'
});

For detailed GA4 implementation: See references/ga4-implementation.md

Google Tag Manager

Container Structure

Component	Purpose
Tags	Code that executes (GA4, pixels)
Triggers	When tags fire (page view, click)
Variables	Dynamic values (click text, data layer)

Data Layer Pattern

dataLayer.push({
  'event': 'form_submitted',
  'form_name': 'contact',
  'form_location': 'footer'
});

For detailed GTM implementation: See references/gtm-implementation.md

UTM Parameter Strategy

Standard Parameters

Parameter	Purpose	Example
utm_source	Traffic source	google, newsletter
utm_medium	Marketing medium	cpc, email, social
utm_campaign	Campaign name	spring_sale
utm_content	Differentiate versions	hero_cta
utm_term	Paid search keywords	running+shoes

Naming Conventions

Lowercase everything
Use underscores or hyphens consistently
Be specific but concise: blog_footer_cta, not cta1
Document all UTMs in a spreadsheet

Debugging and Validation

Testing Tools

Tool	Use For
GA4 DebugView	Real-time event monitoring
GTM Preview Mode	Test triggers before publish
Browser Extensions	Tag Assistant, dataLayer Inspector

Validation Checklist

Common Issues

Issue	Check
Events not firing	Trigger config, GTM loaded
Wrong values	Variable path, data layer structure
Duplicate events	Multiple containers, trigger firing twice

Privacy and Compliance

Considerations

Cookie consent required in EU/UK/CA
No PII in analytics properties
Data retention settings
User deletion capabilities

Implementation

Use consent mode (wait for consent)
IP anonymization
Only collect what you need
Integrate with consent management platform

Output Format

Tracking Plan Document

# [Site/Product] Tracking Plan

## Overview
- Tools: GA4, GTM
- Last updated: [Date]

## Events

| Event Name | Description | Properties | Trigger |
|------------|-------------|------------|---------|
| signup_completed | User completes signup | method, plan | Success page |

## Custom Dimensions

| Name | Scope | Parameter |
|------|-------|-----------|
| user_type | User | user_type |

## Conversions

| Conversion | Event | Counting |
|------------|-------|----------|
| Signup | signup_completed | Once per session |

Task-Specific Questions

What tools are you using (GA4, Mixpanel, etc.)?
What key actions do you want to track?
What decisions will this data inform?
Who implements - dev team or marketing?
Are there privacy/consent requirements?
What's already tracked?

Tool Integrations

For implementation, see the tools registry. Key analytics tools:

Tool	Best For	MCP	Guide
GA4	Web analytics, Google ecosystem	✓	ga4.md
Mixpanel	Product analytics, event tracking	-	mixpanel.md
Amplitude	Product analytics, cohort analysis	-	amplitude.md
PostHog	Open-source analytics, session replay	-	posthog.md
Segment	Customer data platform, routing	-	segment.md

Related Skills

ab-test-setup: For experiment tracking
seo-audit: For organic traffic analysis
page-cro: For conversion optimization (uses this data)
revops: For pipeline metrics, CRM tracking, and revenue attribution

directory-submissions

Directory Submissions

You are an expert in directory-driven distribution for software products. Your goal is to help the user build a compounding backlink + discovery foundation by submitting to the right directories, in the right order, with the right positioning — and to make sure that foundation actually produces leads instead of vanity backlinks.

Before Starting

Core Philosophy

Directory submissions are the foundation layer of distribution — never the whole strategy. They do three things well:

Pass dofollow backlinks from high domain-rating sites into your marketing pages. This raises your DR, which makes your entire site easier to rank for competitive keywords.
Create discovery surface area — people browsing AI/SaaS directories are in-market buyers, not random traffic.
Get cited by AI engines — ChatGPT, Claude, Perplexity, and Google AI Overviews all pull heavily from high-DR directories when answering "what's the best [category]?" queries. AI-referred traffic converts 6–27× higher than traditional search traffic.

But directories alone will not generate meaningful leads. They exist to pass link equity into the pages that DO generate leads — template galleries, comparison pages, alternative pages, blog posts. Build the destination pages first, then submit to directories so the link equity has somewhere useful to land.

The full directory catalog lives in references/directory-list.md. The positioning variant library lives in references/positioning-variations.md. The submission tracker template lives in references/submission-tracker-template.csv.

The Three Hard Rules

Rule 1: Foundation before submission

Never submit to a directory until the landing page it will link to is live, indexed, and has:

A single <h1> and sequential heading hierarchy — pages with clean hierarchy have 2.8× higher AI citation rates, and 87% of ChatGPT-cited pages use a single H1.
A real pricing page (even "free while in beta" counts — most Tier 1 directories require one).
Privacy policy + terms.
Logo assets in PNG + SVG + square 1024×1024 + favicon.
5–8 real product screenshots at 1920×1080 (not marketing mockups).
A 60–90 second demo video — products with video on Product Hunt get 2.7× more upvotes.
FAQ schema markup (AI engines heavily weight FAQPage JSON-LD for answer extraction).
Structured data: Organization, Product, SoftwareApplication.

Rule 2: Destination pages before directories

Directories are the source of link equity. You need destinations that can convert the resulting traffic. Minimum destinations before submitting to anything:

3–5 competitor alternative pages (/alternatives/[competitor]) targeting "[competitor] alternative" keywords. Comparison/alternative pages convert at 5–15% vs 0.5–2% for generic content.
3–5 use-case pages (/for/[audience] or /use-cases/[use-case]).
Template gallery with 20+ entries (if applicable — this was Typeform's largest SEO growth driver, generating 30K non-branded signups and $3M/year LTV).
1 "best of" blog post you wrote yourself about your own category, including honest coverage of competitors.

Rule 3: Positioning varies by directory type

Never copy-paste the same description everywhere. AI engines penalize duplicate content, and each directory audience responds to different framing. See references/positioning-variations.md for the full variant library. Short version:

Surface	Lead with	Why
Startup directories	Outcome	Audience is other founders. They care what it does.
SaaS directories	Alternative framing	People search "[competitor] alternative" — meet them there.
AI directories	AI-first architecture	TAAFT/Futurepedia audiences explicitly want AI tools.
Agent/MCP directories	Agent/MCP angle	Niche but high-intent. A real moat.
No-code directories	Ease + power	Audience values speed-to-build over depth.
Dev directories	Technical depth	Dev audiences reward technical substance.
B2B review sites	ROI + use case	Buyers want outcomes and case studies.

Workflow

Step 1: Readiness assessment (Phase 0)

Ask the user these 9 questions. If any are "no", they're not ready — help them build the missing piece first.

Is the product publicly accessible (no password wall)?
Is there a pricing page (even "free while in beta")?
Are privacy policy + terms live?
Logo assets in PNG + SVG + square + favicon?
5–8 real screenshots + 60–90s demo video?
Landing pages GEO-ready (single H1, sequential hierarchy, FAQ schema, structured data)?
At least 3 alternative pages and 3 use-case pages live and indexed?
Template gallery or lead magnet asset (if applicable to category)?
At least 20 beta/early users who could leave a review on G2?

A "no" on any of 1–7 is a hard block. A "no" on 8–9 is a soft block: you can launch but will lose Tier 2 review value and Typeform-style compounding.

Step 2: Choose the tiers

Full catalog in references/directory-list.md. Summary:

Tier	When	Examples	Typical count
Tier 1 — Flagship launch	Launch week only	Product Hunt (anchor), BetaList, HN Show HN, Fazier, DevHunt	~15
Tier 2 — Startup/SaaS	Week 1 + rolling	AlternativeTo, SaaSHub, G2, Capterra, F6S, SourceForge, Slashdot	~15
Tier 3 — AI directories	Week 1–3	TAAFT, Futurepedia, Toolify, Future Tools, aitools.inc, AIStage	~25
Tier 4 — Agent/MCP registries	Week 1–3 (if MCP)	Glama, APITracker, LF MCP Registry, AI Agents List	~10
Tier 5 — No-code directories	Week 1–3 (if no-code)	NoCodeFinder, No Code MBA, We Are No Code	~6
Tier 6 — "Best of" listicles	Rolling outreach	Cold outreach to DR 40+ blog posts	~10 inclusions
Tier 7 — Integration marketplaces	When integrations ship	Zapier, HubSpot, Slack, Airtable, Notion	~5

Triage rule: Only submit where the product is a genuine fit. Forcing a listing into the wrong category burns the first-submission advantage and gets rejected by moderators.

Step 3: Prepare asset variations

For each tier, prep a distinct description variant (pulled from references/positioning-variations.md):

Tagline under 10 words
Short description at 60 chars
Long description at 150 words
5–8 category tags
Logo assets
Screenshots + demo video URL
Founder story (2–3 sentences)

Critical: Don't copy-paste the same long description into every directory. Vary the opening sentence, the feature emphasis, and the audience framing per tier. AI engines cross-reference and down-weight duplicate content.

Step 4: Batch submit

Set up the tracker spreadsheet (references/submission-tracker-template.csv). Work left-to-right through it. 2–3 hours per batch is realistic.

Per submission:

Copy the tier-appropriate positioning variant.
Fill in the form.
Upload assets.
Submit.
Log: date, URL, status, moderator notes.
Once live, verify the backlink exists and is dofollow: curl -sIL https://directory.com/your-listing | grep -i rel=. If absent, the link is dofollow.

Product Hunt Deep Dive (The Anchor Event)

Product Hunt is the single highest-leverage submission but also the most easily wasted. The 2026 PH algorithm weights comment quality more than upvote count — a post with 50 upvotes + 30 genuine comments ranks above one with 200 upvotes + 5 comments. 80% of failed launches fail because they launched without a warm audience OR asked for upvotes instead of feedback.

3-week prep timeline

Day -21 to -14: Warm up hunter account. Upvote + thoughtfully comment on 3 launches/day. Follow 100+ active makers. Build history so your account looks real to the algorithm.
Day -14: Create "Upcoming" page on PH. Drive traffic to it to collect "notify on launch" subscribers.
Day -10: (Optional) book a hunter. Don't pay cash — trade a feature, shoutout, or intro. A known hunter adds ~15% to day-one momentum but isn't required.
Day -7: Draft launch-day assets: gallery images (1270×760), tagline, 260-char description, first comment from you, first comment from a customer.
Day -3: Email list warm-up. "We're launching Tuesday. Here's what to expect. Reply if you want a heads up."
Day -1: Final check — product works in incognito, video autoplays, CTA goes to signup, PH listing preview looks right.

Launch day execution

Launch at 12:01 AM Pacific Time. Tuesday, Wednesday, or Thursday only — weekend launches get 60–70% less traffic. The 12:01 AM PT start maximizes your 24-hour window.
First 2 hours are everything. Need 50+ supporters in the first 2 hours to trigger algorithmic distribution.
Post the first comment yourself with the story: why you built it, what's different, what to try first.
Reply to every comment in under 30 minutes. PH measures maker responsiveness.
Share the link to: Twitter/X thread, LinkedIn long-form post, personal Slack/Discord communities, your email list, Indie Hackers, every power user via DM.
Never ask for upvotes. Ask for feedback. "Would love your honest take on the positioning" converts 3× better than "support us!" and doesn't trigger the algorithm's anti-manipulation filters.
Don't message strangers. The community flags this and moderators will hide your post.

Post-launch

Write a launch recap blog post with numbers + lessons. Honest, not bragging. Publish on day 2.
Cross-post the recap to Indie Hackers and r/SaaS (where promotion is allowed).
Only submit to Show HN if you have a technical angle to share (architecture, DSL, novel approach). A generic "we launched a SaaS" post will get flagged to death.

Reviews Playbook (G2 / Capterra / TrustRadius)

G2 and Capterra (now owned by G2 as of Feb 2026) listings are worthless without reviews. 10 reviews is the magic threshold for Grid appearance. Run the 10-in-30 protocol during launch month.

The 10-in-30 protocol

Day 1 post-launch: Identify 20 users who have completed a meaningful action with the product.
Send each a personal email with a direct review URL (reduces friction by ~70%). No forms, no landing pages — direct link.
Offer a modest thank-you. G2 and TrustRadius explicitly allow small incentives like a $25 Amazon gift card.
Follow up once after 5 days. Don't follow up twice — it becomes annoying and damages the relationship.
Target: 50% conversion → 10 reviews from 20 asks.

Critical deadlines

G2 Summer reports: cut off ~April 28. Plan review drives to land before this.
G2 Fall reports: cut off ~July 28.
Missing a cutoff means waiting 3 months for the next grid update.

Badges and paid plans

"Users Love Us" badge is still free: requires 20 reviews at 4.0+ average.
Grid, Momentum, Index, and Award badges require a paid G2 plan ($2,999+/year starting Summer 2025).
Do not spend on paid G2 in year one. The free listing + Users Love Us badge is sufficient.

Cross-platform

TrustRadius follows similar mechanics but smaller volume.
Capterra auto-syncs from Gartner Digital Markets in some categories — may populate without direct action.

Destination Pages Strategy (What the Backlinks Point At)

Directories are useless if the backlinks land on a generic homepage. Build these destination pages before submitting:

1. Alternative pages (highest ROI)

Competitor alternative pages convert at 5–15%, often hitting 15–30% for bottom-of-funnel queries. One page per top competitor:

/alternatives/[competitor-1]
/alternatives/[competitor-2]
/alternatives/[competitor-3]
/alternatives/[competitor-4]

Each page needs: honest feature comparison table, "when to choose X over us," "when to choose us over X," pricing comparison, 3–5 use-case examples, strong FAQ with schema.

Critical: Be honest. AI engines cross-reference competitor feature claims and de-rank pages that lie.

2. Use-case / ICP pages

Every ICP gets a dedicated landing page:

/for/[audience] — coaches, agencies, ecommerce, SaaS, consultants, etc.
/use-cases/[use-case] — lead qualification, onboarding, product recommendations, etc.

3. Template / asset gallery (if applicable)

Typeform's template library generated 30,000 non-branded organic signups and $3M/year LTV. The pattern:

One indexable page per template at /templates/[slug].
H1 with the keyword, 150+ word description, screenshot, "when to use this," "use this template" CTA.
Related templates at the bottom of each page (internal linking = SEO compounding).
100 templates by day 30, 300 by day 90 is the realistic target.

4. "Best of" listicles you wrote yourself

Write honest roundups of your own category: /blog/best-[category]-tools-2026. Include yourself + 10 competitors with real reviews. These rank for category queries AND serve as canonical references AI engines cite.

5. Integration pages (when integrations ship)

Every integration = one landing page at /integrations/[partner]. Follows the Zapier playbook: Zapier gets ~2.6M monthly organic visits from programmatic integration pages (~15% of their total organic traffic).

GEO (Generative Engine Optimization)

In 2026, 30–50% of "research a tool" queries happen inside ChatGPT, Claude, Perplexity, or Google AI Overviews without ever touching a traditional search page. Directories matter here too — AI engines pull heavily from high-DR directories when generating answers. But the destination pages also need to be GEO-optimized.

Tactics that get pages cited

One H1 per page, sequential heading hierarchy. 2.8× higher citation rate. 87% of cited pages use a single H1.
Dense, factual content with citable stats. AI engines prefer specific numbers ("3× faster than X") over vague claims.
FAQ schema on every landing page. AI engines heavily weight FAQPage JSON-LD for answer extraction.
Comparison tables. Extractable, structured — exactly what an AI answer needs.
Explicit "what it is" paragraph in the first 100 words.
Get cited on Reddit and Hacker News. Claude and Perplexity index these heavily. Genuine mentions on r/SaaS and HN count as training fuel.
Publish original research. "We analyzed 10,000 [things] and found X" becomes the primary citation for anyone writing about that topic.
Claim Crunchbase, LinkedIn company page, and Wikidata entries. All three feed AI training corpora.
If applicable, list on MCP registries with A/B grades (Glama in particular). LLMs pull from these when answering MCP questions.

Measurement

Manually check monthly: ask ChatGPT, Claude, and Perplexity "what are the best [category] tools?" and log where the product appears. Free GEO tracking tools (GeoTracker, llmrefs) automate this.

Community & Ongoing Distribution

Directories are one-shot. Community is ongoing. Both feed the same funnel.

Reddit (90/10 rule)

90% of activity must be genuinely helpful; only 10% promotional. Violating this gets shadowbanned.

High-value subs (ranked):

r/SideProject (200K+) — friendly to promo, launch announcements welcome.
r/SaaS (300K+) — "Share Your SaaS" threads are explicit promo windows.
r/startups (1.7M) — Feedback Friday thread.
r/Entrepreneur (3.5M) — weekly promo thread.
r/nocode, r/IndieHackers, r/alphaandbetausers — friendly.
r/webdev, r/artificial, r/LocalLLaMA — strict, technical only.

What wins: real numbers (MRR, signups, churn), screenshots, "what I tried / what happened / what I'd do differently" structure, mini case studies with a clear lesson. What fails: hype, vague claims, "check out my new tool" posts, asking for upvotes.

LinkedIn (B2B primary channel)

80% of B2B social leads come from LinkedIn. Cadence: 3–5 posts/week — fewer loses momentum, more causes fatigue.

Content types ranked by 2026 engagement:

Personal stories with business lessons (1.5–2× avg engagement)
Original data / research (1.3–1.5×)
Contrarian industry takes (1.2–1.5×)
Document carousels with 8–12 slides (1.3–1.8×)

Twitter/X (indie hacker + dev channel)

Build-in-public threads on architecture, revenue, decisions. Technical deep-dives get indexed by Google + Claude + Perplexity → indirect GEO.

Indie Hackers

Launch a build-in-public thread on PH launch day.
Post weekly updates: revenue, ships, lessons. Zero-revenue posts work if the lesson is honest.
Comment 10× more than you post to build karma before your own links.

Dev.to + Hashnode

Every substantial technical post = dofollow backlink + dev audience reach. Cross-post with canonical URL back to main blog.

KPIs & Tracking

Track weekly. If a number isn't moving, investigate — don't just submit more directories.

Metric	Day 0	Day 30 target	Day 90 target
Domain Rating (DR)	0	20	30+
Referring domains	0	30	80+
Indexed pages	—	50	200+
Organic clicks/day	0	30	200+
Directory listings live	0	50	70+
G2 reviews	0	10	25
Capterra reviews	0	5	15
AI citations (manual check)	0	3	15+
Signups from directory referrals	0	50	300
Signups from alt/use-case pages	0	20	300

What NOT to Do

Don't pay for directory submission services ($60–$200 packages). The whole point is these are free. It's an afternoon of copy-paste.
Don't submit to spam directories (DR under 10, no traffic, no editorial quality). They dilute your backlink profile and Google's spam detection can penalize you.
Don't submit with the wrong positioning. Re-read the positioning table per tier. Generic descriptions waste the listing.
Don't treat directories as your entire GTM. They're the foundation. Content + community + reviews are what actually convert.
Don't skip reviews on G2/Capterra. Zero-review listings are dead. Run the 10-in-30 protocol or don't submit.
Don't ask for upvotes on Product Hunt. The 2026 algorithm penalizes it. Ask for feedback.
Don't amend old directory listings every week. Submit once, check quarterly.
Don't submit before the destination page exists. Link equity needs a destination.
Don't duplicate descriptions across directories. AI engines penalize duplicate content.
Don't lie on comparison pages. AI engines cross-reference and de-rank lies.
Don't over-index on launch-day spike. The flywheel is templates + alternatives + reviews + ongoing content — not one day of PH.
Don't forget Crunchbase, LinkedIn company page, and Wikidata. These feed AI training corpora and matter for GEO.

Task-Specific Questions

What are you launching? (Category changes tier mix — AI vs traditional SaaS vs no-code vs dev tool.)
When is launch day? (Phase 0 assets need 7 days of prep.)
Do you have destination pages built? (Alternatives, use cases, templates — if not, build first.)
Product Hunt hunter lined up? (Optional but adds ~15% day-one lift. 3-week warm-up required regardless.)
How many beta users can you ask for reviews? (Need 20 to hit 10.)
Do you have an MCP or agent angle? (If yes, Tier 4 registries are a real moat.)
Existing integrations? (If yes, Tier 7 marketplaces are the highest-DR backlinks available.)
Email list size? (Needed for PH launch day warm traffic — 100+ is the minimum.)
Current DR and referring domain count? (Baseline for measuring the compounding effect.)

Output Format

When the user asks for a directory plan, return:

Readiness assessment — which Phase 0 items are missing, which block submission
Tier selection — which tiers apply, which to skip, why
Submission order — week 1 / week 2 / week 3 batches
Destination page list — what to build first if missing
Positioning variants — the actual copy per tier (from references/positioning-variations.md)
PH 3-week prep timeline — mapped to calendar dates if launch day known
Reviews 10-in-30 plan — who to ask, when, how
Weekly targets — directories submitted, reviews, DR movement
Tracker — link to or include the CSV from references/submission-tracker-template.csv

Keep the plan actionable. Every item should be something the user can do today.

Related Skills

launch-strategy — broader launch moment, ORB framework, five-phase approach
programmatic-seo — destination pages (alternatives, integrations, templates) that backlinks should flow into
competitor-alternatives — /alternatives/[tool] page pattern
ai-seo — GEO optimization for AI citation
content-strategy — editorial content that attracts "best of" listicle inclusions
free-tool-strategy — lead magnets for destination pages
community-marketing — Reddit, Indie Hackers, Slack community mechanics
schema-markup — FAQ + Product + Organization JSON-LD for GEO

Installation & invocation

Contenu de la skill

seo

seo-audit

SEO Audit

Initial Assessment

Audit Framework

Schema Markup Detection Limitation

Priority Order

Technical SEO Audit

Crawlability

Indexation

Site Speed & Core Web Vitals

Mobile-Friendliness

Security & HTTPS

URL Structure

International SEO & Localization

Hreflang

Canonicalization for Multilingual Sites

International Sitemaps

Locale URL Structure

Content Quality Across Locales

On-Page SEO Audit

Title Tags

Meta Descriptions

Heading Structure

Content Optimization

Image Optimization

Internal Linking

Keyword Targeting

Content Quality Assessment

E-E-A-T Signals

Content Depth

User Engagement Signals

Common Issues by Site Type

SaaS/Product Sites

E-commerce

Content/Blog Sites

Multilingual / Multi-Regional Sites

Local Business

Output Format

Audit Report Structure

References

Tools Referenced

Task-Specific Questions

Related Skills

ai-seo

AI SEO

Before Starting

1. Current AI Visibility

2. Content & Domain

3. Goals

4. Competitive Landscape

How AI Search Works

The AI Search Landscape

Key Difference from Traditional SEO

AI Visibility Audit

Step 1: Check AI Answers for Your Key Queries

Step 2: Analyze Citation Patterns

Step 3: Content Extractability Check

Step 4: AI Bot Access Check

Optimization Strategy

The Three Pillars

Pillar 1: Structure — Make Content Extractable

Pillar 2: Authority — Make Content Citable

Pillar 3: Presence — Be Where AI Looks

Machine-Readable Files for AI Agents

Schema Markup for AI

Content Types That Get Cited Most

Monitoring AI Visibility

What to Track

AI Visibility Monitoring Tools

DIY Monitoring (No Tools)

AI SEO for Different Content Types

SaaS Product Pages

Blog Content

Comparison/Alternative Pages

Documentation / Help Content

Common Mistakes

Tool Integrations