⏳ This skill is pending AI review.

Scores will appear once the review pipeline completes.

v2.1

seo-audit-full

jeffli1993@jeffli1993⭐ 785 stars· last commit 5mo ago· 0 open issues

>-

Choose how to use this skill

You do not need every option. Choose the path your AI client supports. The stable page stays the same; versioned files are immutable.

1. Native installer

This listing has no registered native installer command. Use the complete package or source fallback below, depending on what your client supports.

Do not guess an installer command or replace an existing version without reviewing the diff.

2. Complete package recommended

Download the ZIP when available. It includes SKILL.md plus the references, security notes and version metadata.

No complete ProSkills package is published for this listing yet.

3. Prompt-only

Copy the prompt above when the agent can read the stable page or when you want to adopt the workflow without installing a skill.

Need only the instruction file?

Download SKILL.md only if your client requires a single file. The complete ZIP is safer for a full installation because it preserves the references and release context.

No path installs or executes anything by itself. Your agent still needs access to the project files. Before updating, compare the installed version and review the diff.

—/10

// RATINGS

⭐GitHub Stars
⭐⭐⭐⭐ 785 on GitHubGitHub ↗

Popular

🟢ProSkills Score
—
📍

Not yet listed on ClawHub or SkillsMP

// README

seo-audit-skill

English · 中文 · SEO Audit Agent Skill

Reusable Agent Skills for single-page SEO auditing. Give it a URL — get a structured HTML report with actionable findings.

Built on a Script + LLM two-layer architecture: Python scripts handle deterministic checks (HTTP status, XML parsing, string matching), while the LLM handles semantic judgment (keyword intent, content quality, page type inference). Works with Claude Code, Cursor, and any agent runtime that supports SKILL.md.

Best practices

  1. Run npx skills add JeffLi1993/seo-audit-skill, then audit your page (for example: audit this page: https://example.com). Open the report at reports/<hostname>-audit.html and review it yourself: keep what matters for your goals, skip what does not.
  2. Share the report (or the key sections) with Cursor or Claude Code and have the assistant work through the findings and fixes item by item.

Report Output

Each basic audit produces a standalone HTML report saved to reports/<hostname>-audit.html. Full audits save to reports/<hostname>-full-audit.html.

SectionWhat you get
Audit SummaryOne-line verdict + critical / warnings / passing at a glance
Site ChecksSitemap URL Inventory · Crawlability · URL Canonicalization · i18n · Schema · E-E-A-T
Page SpeedFull only — Lighthouse scores, lab metrics, final URL, screenshot availability
Page ChecksTDK · H1 · Headings · Word Count · Internal Links · Social Tags
Priority ActionsTop 3 highest-impact fixes, ranked
Insight WalkthroughEvidence → Impact → Fix for each major finding
audit this page: https://openclaw.ai
→ ✅ Report saved → reports/openclaw-ai-audit.html
WebsiteAudit SummarySite ChecksPage Checks & insights
colaos.ai

Skills

SkillTierWhen to use
seo-auditBasicDefault — give it a URL, get a 20+ check structured report
seo-audit-fullFullDeep audit with PageSpeed, sitemap inventory, social tags, content quality, GSC data, competitor gap

seo-audit-full requires a Google PageSpeed Insights API key for PageSpeed checks. Set PAGESPEED_API_KEY / GOOGLE_PAGESPEED_API_KEY, or pass --api-key; without a key, the full audit stops and asks you to configure one.


Audit Coverage

Site-level

CheckWhat it verifiesBasicFull
Sitemap URL InventoryStandalone table of top sitemap directories: URL count, page type, representative example URL—✅
Staging Subdomain IndexationDetects public test., staging., dev., preview., beta., uat. hosts that mirror production and may be indexable—✅
robots.txtRFC 9309 group parsing, Allow/Disallow logic, Googlebot status, Sitemap directives✅✅
sitemap.xmlValid XML, URL count, follows Sitemap directive path from robots.txt, samples child sitemap URLs when needed✅✅
404 HandlingTrue 404 vs soft 404 (200) vs redirect-to-homepage (301)✅✅
URL CanonicalizationHTTP→HTTPS redirect, www consistency, trailing slash, canonical tag match✅✅
i18n / hreflangReciprocal symmetry, BCP 47 codes, x-default, default-language URL duplication, canonical/hreflang alignment✅✅
Schema (JSON-LD)Parseability, @type detection, required/recommended fields, nested fields, type conflicts, localized schema language/URL alignment✅✅
E-E-A-T Trust PagesAbout / Contact / Privacy / Terms — exists (HTTP 200) + reachable from footer/nav✅✅
GSC Crawl StatusIndex coverage, crawl errors, blocked resources—✅
PageSpeed / LighthousePerformance · Accessibility · Best Practices · SEO scores, lab metrics, final URL, screenshot availability—✅

Sitemap URL Inventory is intentionally rendered as its own table before Crawlability:

DirectoryURL CountPage TypeExample Page
/blog/300Blog / Content Pageshttps://xx.ai/blog/best-ai-video-tools
/tools/80Tool Pageshttps://xx.ai/tools/image-generator
/alternatives/40Alternative / Competitor Pageshttps://xx.ai/alternatives/synthesia

Use it as a site-level map, then choose representative URLs from important directories for deeper full audits.

Page-level

CheckWhat it verifiesBasicFull
URL SlugLowercase, hyphenated, keyword present, stop word & stuffing detection✅✅
Title Tag50–60 chars, keyword position, homepage vs inner page rules✅✅
Meta Description120–160 chars, keyword match, concrete value prop (not generic fluff)✅✅
H1 TagSingle H1, keyword match (full / partial / none), semantic intent review✅✅
Canonical TagSelf-referencing, matches final URL after redirects✅✅
Image Alt TextAlt attribute check on all <img>, JS-render detection✅✅
Word CountBody text ≥ 500 words, thin content flag✅✅
Keyword PlacementPrimary keyword within first 100 body words✅✅
Heading StructureH2 count (target 5–7), H3/H2 ratio, keyword distribution in H2s✅✅
Internal LinksSame-origin links (excl. nav/footer), equity distribution✅✅
OG / Social Tagsog:image, twitter:card, social preview completeness—✅
Content QualityE-E-A-T depth, readability, specificity vs competitors—✅
Robots Metanoindex, nofollow, max-snippet directives—✅

Structure

seo-audit-skill/
├── seo-audit/
│   ├── SKILL.md                       # Skill definition + agent workflow
│   ├── references/REFERENCE.md        # Field definitions, edge cases
│   ├── assets/report-template.html    # HTML output template
│   └── scripts/
│       ├── check-site.py              # robots.txt + sitemap → JSON
│       ├── check-page.py              # TDK + H1 + canonical + slug → JSON
│       ├── check-schema.py            # JSON-LD extraction + validation → JSON
│       └── fetch-page.py              # Raw HTML fetcher, SSRF protection
└── seo-audit-full/
    ├── SKILL.md
    ├── references/REFERENCE.md
    ├── assets/report-template.html
    └── scripts/
        ├── check-site.py              # staging + sitemap inventory + robots/sitemap → JSON
        ├── check-pagespeed.py         # PageSpeed Insights / Lighthouse → JSON
        ├── check-social.py            # OG + Twitter Card validation → JSON
        └── check-schema.py            # JSON-LD quality + localized schema validation → JSON

Architecture: Script + LLM

URL
 │
 ▼
┌──────────────────────────────────────────────────┐
│  Layer 1 · Python Scripts                        │
│  Deterministic checks → structured JSON          │
│                                                  │
│  check-site.py      sitemap inventory, staging   │
│  check-page.py      H1 / title / meta / canonical│
│  check-schema.py    JSON-LD fields + localization│
│  fetch-page.py      raw HTML + SSRF protection   │
└───────────────────────┬──────────────────────────┘
                        │ JSON + llm_review_required flag
                        ▼
┌──────────────────────────────────────────────────┐
│  Layer 2 · LLM Agent                             │
│  Semantic judgment on flagged fields only         │
│                                                  │
│  · Keyword intent alignment (H1 / title)         │
│  · Meta description quality & specificity        │
│  · Page type → expected Schema @type mapping     │
│  · E-E-A-T trust page reachability (footer/nav)  │
│  · Content analysis (word count, heading, links) │
└───────────────────────┬──────────────────────────┘
        

// HOW IT'S BUILT

// FILES

2 files shipped with this skill. Inline text is the catalog copy. The upstream link is the source repository.

  • seo-audit-full/SKILL.md8.9 KBupstream ↗
    ---
    name: seo-audit-full
    description: >-
      Advanced full SEO audit skill. Runs its own full workflow from local scripts,
      including the basic SEO checks plus PageSpeed, social metadata, and advanced
      review modules when available.
    metadata:
      author: Jeff
      version: "2.1"
    ---
    
    # seo-audit-full — Advanced Full SEO Audit
    
    This skill runs a full single-page SEO audit from the `seo-audit-full` directory.
    It does not route to `seo-audit` when only a URL is provided.
    
    ---
    
    ## When to Use This Skill
    
    Use `seo-audit-full` when the user asks for:
    
    - "seo-audit-full"
    - "full SEO audit"
    - "advanced SEO audit"
    - "technical SEO audit"
    - "deep audit"
    - "comprehensive SEO review"
    - "audit everything"
    
    URL-only requests are valid. When external datasets are not supplied, run the
    full public-signal workflow and clearly note missing data sources in the report.
    
    ---
    
    ## Input Expected
    
    | Input | Required | Notes |
    |-------|----------|-------|
    | Page URL | Yes | The primary page to audit |
    | Primary keyword | Recommended | Improves content relevance scoring |
    | PageSpeed API key | Yes | Required for full audit PageSpeed checks. Ask at the start and do not run PageSpeed without it. |
    | Raw HTML or page content | Optional | Enables more accurate content checks when supplied |
    | GSC / crawl / analytics data | Optional | Include when supplied, otherwise mark unavailable |
    | Competitor benchmark data | Optional | Include when supplied |
    
    At the start of a full audit, ask the user for a PageSpeed Insights API key:
    
    ```
    For PageSpeed checks, please provide a Google PageSpeed Insights API key.
    Get one here: https://developers.google.com/speed/docs/insights/v5/get-started
    Open "Acquiring and using an API key" → "Get a Key".
    If you do not provide one, I will stop before running the full audit because
    PageSpeed is a required full-audit module.
    ```
    
    Do not run `seo-audit-full` PageSpeed checks without a PageSpeed API key supplied
    by `--api-key`, `PAGESPEED_API_KEY`, or `GOOGLE_PAGESPEED_API_KEY`. If the key is
    missing, stop and ask the user to configure it instead of rendering a full report
    with missing PageSpeed data.
    
    ---
    
    ## Architecture: Full = Core + Performance + Advanced
    
    ```
    ┌─────────────────────────────────────────────────────────────┐
    │  seo-audit-full Workflow                                    │
    │                                                             │
    │  Phase 1: Run core scripts (./scripts/)                     │
    │  ┌──────────────────────────────────────────────────────┐   │
    │  │  check-site.py      → robots.txt, sitemap, 404, URL  │   │
    │  │  check-page.py      → title, H1, meta desc, slug     │   │
    │  │  check-schema.py    → JSON-LD validation              │   │
    │  │  fetch-page.py      → raw HTML for analysis           │   │
    │  └──────────────────────────────────────────────────────┘   │
    │                          ↓                                  │
    │  Phase 2: Run performance + full-only scripts (./scripts/)  │
    │  ┌──────────────────────────────────────────────────────┐   │
    │  │  check-pagespeed.py → Lighthouse scores + metrics     │   │
    │  │  check-social.py    → OG Tags + Twitter Card          │   │
    │  │  (more scripts added here as modules grow)            │   │
    │  └──────────────────────────────────────────────────────┘   │
    │                          ↓                                  │
    │  Phase 3: LLM-only advanced checks                         │
    │  ┌──────────────────────────────────────────────────────┐   │
    │  │  E-E-A-T content quality scoring                      │   │
    │  │  Duplicate content signals                            │   │
    │  │  Anchor text quality assessment                       │   │
    │  └──────────────────────────────────────────────────────┘   │
    └─────────────────────────────────────────────────────────────┘
    ```
    
    ---
    
    ## Output
    
    Produce an **Advanced Full SEO Audit Report** by filling the template at
    [assets/report-template.html](assets/report-template.html),
    then **save it to a file — never print raw HTML to the terminal**.
    
    **File naming:** `reports/<hostname>-<slug>-full-audit.html`
    ```
    https://example.com/blog/best-tools → reports/example-com-blog-best-tools-full-audit.html
    https://example.com/                → reports/example-com-full-audit.html
    ```
    
    **After saving, tell the user:**
    ```
    ✅ Full Report saved → reports/example-com-full-audit.html
       Open it now? (yes / no)
    ```
    If yes → run: `open reports/example-com-full-audit.html`
    
    **Template placeholders** — fill each independently:
    
    | Placeholder | Content |
    |---|---|
    | `{{summary_verdict}}` | One sentence: total checks run, how many failed/warned/passed |
    | `{{summary_critical_html}}` | `<li>` per critical item, or `<li class="summary-empty">None</li>` |
    | `{{summary_warnings_html}}` | `<li>` per warning item, or `<li class="summary-empty">None</li>` |
    | `{{summary_passing_html}}` | `<li>` per passing check, or `<li class="summary-empty">None</li>` |
    | `{{pagespeed_checks_html}}` | Full PageSpeed module using `check-pagespeed.py` output |
    | `{{site_checks_html}}` | Site-level check tables |
    | `{{eeat_checks_html}}` | E-E-A-T trust page table |
    | `{{page_checks_html}}` | Page-level check tables, including full-only additions |
    | `{{priority_actions_html}}` | Ordered priority action list |
    | `{{insights_html}}` | Optional finding walkthrough cards |
    
    ---
    
    ## Scripts
    
    Run full scripts from this directory. All output is structured JSON — use it
    directly as evidence.
    
    **Dependencies:** `pip install requests`
    
    ### Phase 1: Core scripts
    
    ```bash
    # 1. site-level checks (robots.txt + sitemap.xml + 404 + URL canonicalization)
    python scripts/check-site.py https://example.com
    
    # 2. page-level checks (H1, title, meta description, canonical, URL slug)
    python scripts/check-page.py https://example.com --keyword "primary keyword"
    
    # 3. fetch raw HTML for downstream scripts
    python scripts/fetch-page.py https://example.com --output /tmp/page.html
    
    # 4. JSON-LD schema validation
    python scripts/check-schema.py --file /tmp/page.html
    ```
    
    ### Phase 2: Full-only scripts
    
    ```bash
    # 5. PageSpeed / Lighthouse checks
    python scripts/check-pagespeed.py https://example.com --strategy mobile --timeout 180 --api-key "USER_PROVIDED_KEY"
    # If no key was provided, do not run this command. Ask the user to configure a PageSpeed API key first.
    
    # 6. Social tags: OG + Twitter Card validation
    python scripts/check-social.py --file /tmp/page.html
    # Or directly from URL:
    python scripts/check-social.py https://example.com
    ```
    
    Each script exits with code `0` (all pass/warn) or `1` (any fail/error).
    
    PageSpeed can take 200 seconds. Use a 180-second timeout by default. If it
    still times out, mark the Page Speed module as `error` and state that the
    PageSpeed API timed out; do not treat that as confirmed page performance failure.
    If PageSpeed fails because Google returns a quota/API-key error after a key was
    provided, keep the audit running and render the PageSpeed module as `error` with
    this instruction:
    `Get a PageSpeed API key at https://developers.google.com/speed/docs/insights/v5/get-started → "Acquiring and using an API key" → "Get a Key".`
    
    ---
    
    ## Scope — Full Audit Check Whitelist
    
    Full runs its own core checks plus the full-only items marked ★ below.
    
    ### Site-Level Checks (in `{{site_checks_html}}`)
    
    Core checks:
    - Sitemap URL Inventory · Staging Subdomain Indexation · robots.txt · sitemap.xml · 404 Handling · URL Canonicalization · i18n / hreflang
    
    **Staging Subdomain Indexation rules:**
    - Check common staging/test hosts before robots.txt: `test.`, `staging.`, `dev.`, `preview.`, `beta.`, `uat.`
    - **Fail** when a staging/test subdomain is publicly accessible, closely mirrors the production site, and is not protected by authentication, `noindex`, or a blocking `robots.txt`.
    - **Warn** when a staging/test subdomain is publicly accessible but similarity or index protection cannot be confirmed.
    - **Pass** when no public staging/test subdomain is detected, or detected staging hosts are protected by authenticatio
  • README.mdupstream ↗

    Contents are not inlined in the catalog. Open the upstream file.

Plain-text copy, no login: /skill-bundles/jeffli1993-seo-audit-skill-seo-audit-full.md

// REPO STATS

785 stars
0 open issues
Last commit: 5mo ago