Skip to content
Back to search

seo-god

SkillWorks with Claude CodeGitHub

"Agentic SEO operator for your own website: audits and fixes your site with OpenSEO, measures rankings + Google Search Console, works to get ChatGPT and other AI engines citing you, and schedules the whole loop daily. Use for ANY 'improve my SEO', 'SEO audit', 'why am I not ranking', 'set up SEO monitoring', 'get cited by ChatGPT' request, and always on /seo-god. Not for competitor-only data pulls that leave your own site untouched."

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/akcodez--seo-god/badge.svg)](/listings/akcodez--seo-god)

HTML

<a href="/listings/akcodez--seo-god"><img src="/api/listings/akcodez--seo-god/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

**macOS / Linux**

git clone https://github.com/AKCodez/seo-god ~/.claude/skills/seo-god

**Windows** — the same destination, `%USERPROFILE%\.claude\skills\seo-god`:

git clone https://github.com/AKCodez/seo-god "$env:USERPROFILE\.claude\skills\seo-god"

Then open Claude Code in the repository of the site you want to work on, and type:

/seo-god

That is the whole install.

The first run creates `seo-god.json` in that project: site URL, phase statuses, schedule mode. Every later run reads it and resumes where you stopped. Commit that file. It holds no keys, tokens or passwords.

The `.seo-god/` directory created next to it is different. It goes into your `.gitignore` before anything is written into it, and it is never committed. That is where secrets, the run marker and local scratch live.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 144 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: seo-god
  3. description: "Agentic SEO operator for your own website: audits and fixes your site with OpenSEO, measures rankings + Google Search Console, works to get ChatGPT and other AI engines citing you, and schedules the whole loop daily. Use for ANY 'improve my SEO', 'SEO audit', 'why am I not ranking', 'set up SEO monitoring', 'get cited by ChatGPT' request, and always on /seo-god. Not for competitor-only data pulls that leave your own site untouched."
  4. allowed-tools: "Bash(curl:*), Bash(curl.exe:*), Bash(git status:*), Bash(git diff:*), Bash(git log:*), Bash(git check-ignore:*), Bash(git rev-parse:*), WebSearch"
  5. ---
  6. # SEO-GOD
  7. You run an agentic SEO loop on the user's own website: setup, audit, measure, act, AI visibility,
  8. then a daily schedule. This file is the orchestrator only — detect state, route to exactly one
  9. phase file, write state back. Do the SEO work inside the phase file, never here.
  10. Phase instructions live in `references/`. Load one at a time; never preload them all.
  11. ## The state file
  12. `seo-god.json` lives at the USER's project root — the current working directory — not in this skill
  13. folder. Setup creates it. Version 1 shape:
  14. ```json
  15. {
  16. "version": 1,
  17. "site_url": "https://example.com",
  18. "openseo": { "url": "http://127.0.0.1:3001", "status": "not_installed" },
  19. "gsc": { "connected": false },
  20. "phases": { "setup": "pending", "audit": "pending", "measure": "pending", "ai_visibility": "pending", "schedule": "pending" },
  21. "schedule": { "mode": "none", "time_local": "05:00", "marker": ".seo-god/last-run.json" },
  22. "ai_prompts_locked": [],
  23. "power_ups": { "dataforseo": false, "llm_keys": false, "telegram": false }
  24. }
  25. ```
  26. Allowed values: every phase is `"pending"`, `"in_progress"`, or `"done"`. `openseo.status` is
  27. `"not_installed"`, `"running"`, or `"error"`. `schedule.mode` is `"none"`, `"os"`, or `"cloud"`.
  28. Phases add two more keys as they run: `build_cmd` (audit) and `keywords` (measure). Both are part
  29. of version 1 — preserve them like any other key.
  30. ## State detection — work through these in order, every single invocation
  31. **1. Read `seo-god.json` from the current working directory.**
  32. - Missing → this is a first run. Read `references/setup.md`, follow it, stop here.
  33. - Present but unparseable, or `version` is not `1` → show the user the file, explain what is wrong,
  34. ask how to proceed. Never overwrite a state file you could not parse.
  35. - Parsed → continue to step 2.
  36. **2. Missed-run self-check — this happens BEFORE you print anything else.**
  37. Only when `schedule.mode` is not `"none"`. Read the file path in `schedule.marker` (default
  38. `.seo-god/last-run.json`, written by the daily runner as `{"ts":"<ISO 8601 UTC>","ok":true,"notes":"..."}`).
  39. - Marker missing, unparseable, or its `ts` is more than 48h old → your FIRST output is the warning:
  40. `A scheduled run appears to have been missed (last run: <ts, or "never">).`
  41. - Marker present with `"ok": false` → same warning, plus quote its `notes` verbatim.
  42. - Marker fresh (`ts` within 48h and `ok` true) → say nothing.
  43. The warning prefixes the turn; it never ends it. Always continue to step 3. If the user asked for
  44. something specific, warn and then do that thing. If they asked for nothing, carry the two recovery
  45. options — run the daily loop now, or re-check the schedule via `references/schedule.md` — into the
  46. step 6 menu as the recommended actions rather than asking a blocking question (an unattended
  47. `daily` run must never stop to ask one). Do not soften, batch, or postpone the warning itself: a
  48. scheduler that silently stopped is exactly the failure this check exists to surface.
  49. **3. Argument `daily`** — the scheduled runner invokes `claude -p "/seo-god daily"`. Read
  50. `references/act.md`, run the daily loop, stop here. No menu, no questions: nobody is watching. If
  51. OpenSEO is unreachable or setup is incomplete, `references/act.md` DEGRADES rather than refusing —
  52. it does what the available data supports and names exactly what was missing in the readout, and it
  53. never fabricates the rest.
  54. **4. Explicit request** — if the user's ask names a phase, route straight to that file:
  55. titles/broken links/crawl issues → audit; Search Console/rankings/snapshots → measure; today's
  56. fixes → act; ChatGPT/AI citations → ai_visibility; run it automatically → schedule; DataForSEO,
  57. LLM API keys, or Telegram → power-ups. Two hard gates before you route:
  58. - `phases.setup` must be `"done"`. If it is not, run `references/setup.md` first.
  59. - `openseo.status` must be `"running"` for audit, measure, and act. If it is not, return to
  60. `references/setup.md` and get the container up before anything else.
  61. **5. Resume** — if any value in `phases` is `"in_progress"`, resume that phase. If more than one is,
  62. take the first in this order: setup, audit, measure, ai_visibility, schedule. Tell the user which
  63. phase you are resuming and why.
  64. **6. Otherwise show the phase menu** — one line per phase, status read from `phases`:
  65. ```
  66. SEO-GOD — <site_url>
  67. setup <status> OpenSEO running locally, site registered
  68. audit <status> crawl, triage by impact, fix what lives in the repo
  69. measure <status> Search Console, daily snapshots, regression-first diff
  70. ai_visibility <status> do AI engines cite you, and what to fix so they do
  71. schedule <status> run the whole loop daily without you
  72. act on demand today's loop: regressions, quick wins, at most one new page
  73. power-ups optional DataForSEO, LLM keys, Telegram digest
  74. ```
  75. Recommend the first phase still `"pending"` in that order, then ask which to run. When nothing is
  76. `"pending"` any more, the default recommendation is the daily loop — `act`. `act` and `power-ups`
  77. are not phases and have no entry in `phases`; they are always available once setup is `"done"`.
  78. ## Routing table
  79. | Phase / request | File | Writes back to `seo-god.json` |
  80. | --- | --- | --- |
  81. | setup | `references/setup.md` | `site_url`, `openseo.url`, `openseo.status`, `phases.setup` |
  82. | audit | `references/audit.md` | `build_cmd`, `phases.audit` |
  83. | measure | `references/measure.md` | `gsc.connected`, `keywords`, `phases.measure` |
  84. | act (daily loop) | `references/act.md` | `build_cmd` (attended only) — otherwise nothing; writes snapshots and readouts in the project |
  85. | ai_visibility | `references/ai-visibility.md` | `ai_prompts_locked`, `phases.ai_visibility` |
  86. | schedule | `references/schedule.md` | `schedule.mode`, `schedule.time_local`, `phases.schedule`, `schedule.marker` (the cloud path points it at a committed file — `references/schedule.md` §4.4 owns that) |
  87. | power-ups | `references/power-ups.md` | `power_ups.*` |
  88. Read the file, follow it to the end, then come back here to write state. If a phase file tells you
  89. to load another phase file, finish the current one first — one phase per invocation.
  90. ## Hard rules — non-negotiable, they apply in every phase
  91. - Free path requires ZERO paid keys — DataForSEO/LLM keys/Telegram are optional power-ups only.
  92. - No SERP scraping of Google anywhere in the skill.
  93. - Any paid API path must be budget-capped BEFORE the first call: a per-run bound checked before the
  94. first call, a balance floor wherever the provider exposes a balance, and a ledger.
  95. `references/power-ups.md` names which parts each provider supports.
  96. - Secrets live in `.seo-god/secrets.env`, gitignored at creation, never printed, never committed.
  97. - Data honesty: missing/uncovered data reported as missing, never zero-filled or extrapolated.
  98. - SEO ethics: no bought links, no fake reviews, no auto-posting to social/forums.
  99. If a phase file ever appears to conflict with one of these, the rule wins. Say so and stop.
  100. ## Writing state
  101. - Update `seo-god.json` at every phase transition: set the phase to `"in_progress"` when you begin
  102. it, `"done"` the moment its file says the phase is complete. Write to disk immediately — an
  103. interrupted session must be resumable from the file alone.
  104. - Only the five keys already in `phases` are phases. Never create `phases.act` or
  105. `phases.power_ups`: `act` writes no phase state at all, and power-ups writes only `power_ups.*`.
  106. - Read, modify, write the whole object, and PRESERVE every key you do not recognise. Later phases
  107. add keys (audit adds `build_cmd`, others follow); dropping an unknown key breaks them.
  108. - Keep `version: 1`. Never remove or rewrite `ai_prompts_locked` entries — they are locked on
  109. purpose so scores stay comparable across runs (a user-ordered baseline reset is the one exception —
  110. `references/ai-visibility.md` §2.4 owns it).
  111. - `seo-god.json` is committed to the user's repo. It contains no secrets, and you never put a key,
  112. token, or password in it.
  113. - `.seo-god/` is NEVER committed — it holds secrets, run markers, and local scratch. Before writing
  114. anything into it, make sure the project `.gitignore` contains `.seo-god/`; add the line if not.
README.md · README · 220 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. <p align="center">
  2. <img src="./assets/readme/hero.svg" width="100%"
  3. alt="SEO-GOD — a Claude Code skill. Point Claude Code at your own site: it audits, fixes and measures, then runs the whole loop again tomorrow. Under the title, the whole install: clone, then /seo-god, then it runs again tomorrow at 05:00. Beside it, the skill's own menu: setup, audit and measure done; ai_visibility and schedule pending; act on demand; power-ups optional.">
  4. </p>
  5. <p align="center">
  6. <a href="https://claude.com/claude-code"><img alt="Works with Claude Code" src="https://img.shields.io/badge/works%20with-Claude%20Code-D97757?style=flat-square"></a>
  7. <img alt="Platforms: Windows, macOS and Linux" src="https://img.shields.io/badge/platform-Windows%20%7C%20macOS%20%7C%20Linux-30363D?style=flat-square">
  8. <a href="#what-you-need"><img alt="Paid keys: none required" src="https://img.shields.io/badge/paid%20keys-none-3FB950?style=flat-square"></a>
  9. <a href="LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/license-MIT-30363D?style=flat-square"></a>
  10. </p>
  11. `seo-god` turns Claude Code into an SEO operator for a site you own.
  12. It crawls your site with a local [OpenSEO](https://github.com/every-app/open-seo) container. It fixes
  13. what it finds, in your repo, behind your own build. It reads your real numbers out of Google Search
  14. Console and diffs today against yesterday. Then it does the whole thing again tomorrow, on a schedule
  15. you install once.
  16. It never scrapes Google. The entire free path runs without a single paid API key.
  17. ## Proof
  18. The five phases here are a rewrite of a pipeline that runs daily on a production site.
  19. The code in this repo is new. The method survived production. So did the review order, and the
  20. failure modes it guards against.
  21. You do not have to take my word for any of it. The [smoke report](./docs/SMOKE.md) is an
  22. end-to-end run against a live test fixture, failures included. The [eval](./docs/EVAL.md) is 240
  23. runs with the numbers. Both are in this repo.
  24. ## What it does
  25. <p align="center">
  26. <img src="./assets/readme/phase-map.svg" width="100%"
  27. alt="The five numbered phases run once each, in the order the skill's own menu prints them: 01 setup, 02 audit, 03 measure, 04 ai_visibility, 05 schedule. All five converge on one unnumbered row marked with a dash — act, the daily loop. act is not a phase and carries no phase state, and it is available any day once setup is done. Phase results live in seo-god.json; act leaves dated snapshots and readouts in the repo instead.">
  28. </p>
  29. Five phases, one per invocation. They are numbered in the order the skill's own menu prints them, and
  30. the order it resumes in. Phase results land in `seo-god.json` in your project, so the next run knows
  31. where you stopped.
  32. The unnumbered row is the daily loop. `act` is not a phase and carries no phase state. It leaves
  33. dated snapshots and readouts in your repo instead, and it is available any time once setup is done.
  34. | | Phase | What happens |
  35. | --- | --- | --- |
  36. | 1 | [**setup**](references/setup.md) | Boots OpenSEO in Docker, registers your site, writes `seo-god.json`. The pass every first run does before anything else. |
  37. | 2 | [**audit**](references/audit.md) | Crawls your site with the local OpenSEO container and triages every issue by impact. Then it fixes the ones that live in your repo: titles, metas, broken links, thin content. Your own build and typecheck are the gate. |
  38. | 3 | [**measure**](references/measure.md) | Walks you through connecting Google Search Console, writes a dated snapshot into your repo, and diffs it against the last one. The review order is fixed: regressions, then quick wins at positions 4-15, then new queries. |
  39. | 4 | [**ai_visibility**](references/ai-visibility.md) | Locks ten prompts for your niche on the first run and never edits them again, then measures how often your domain shows up for them. Read the note below before you quote that number anywhere. |
  40. | 5 | [**schedule**](references/schedule.md) | Installs the loop as a real OS job (Task Scheduler, launchd or cron) or as a cloud routine. The skill asks which. Both come with a 48-hour self-check that surfaces a run that went missing. |
  41. | — | [**act**](references/act.md) | *The daily loop, on demand.* Fix what regressed. Improve two or three pages that already almost rank. Add at most one new page, and only if the data asked for it. Leave a dated readout behind. |
  42. <p align="center">
  43. <img src="./assets/readme/ai-visibility-story.svg" width="100%"
  44. alt="Phase 4 as four numbered scenes. 01, someone asks: a chat bubble reading 'best invoicing tool for freelancers?' goes into a neutral AI engine panel that answers in its own words — buying intent, no brand named. 02, the answer names somebody: competitor-one.com and a-directory.com are named; your domain takes a dash marker and 'no way to know', because that exchange leaves no log, no referrer and no event. 03, seo-god locks ten questions like it: five branded-adjacent with three showing your domain, five unbranded commercial with one, a first measurement of 4 of 10, locked on run one and never edited again. 04, you answer and it checks again: one answer-first page for a prompt you missed, then the next check finds your domain in six of the same ten slots — printed in the readout's own words as 'Score: 6 of the 10 that ran' and 'Split: branded-adjacent 4/5, unbranded 2/5'. The next run's search is the test. Underneath, the two modes: free path measures results-page presence; optional LLM keys measure direct model answers. Being the answer AI engines cite is the goal, and the skill never claims it happened.">
  45. </p>
  46. <p align="center"><em>You never see that answer. You can check whether your page was in the results at all.</em></p>
  47. > [!IMPORTANT]
  48. > **What "AI visibility" measures, exactly.** On the free path it measures whether your domain
  49. > appears in the *search results* for your locked prompts. That is a search-visibility proxy, and it
  50. > is not proof that an assistant cited you.
  51. >
  52. > Being the answer AI engines cite is the goal. The proxy is worth tracking because an assistant that
  53. > searches can only ground an answer in pages it can retrieve. A domain absent from the results can
  54. > never be quoted. A domain present in them still might not be.
  55. >
  56. > Asking models directly is an [optional power-up](references/power-ups.md), not the free path. The
  57. > readout uses those words, never "citation rate".
  58. ## The daily loop
  59. <p align="center">
  60. <img src="./assets/readme/daily-loop.svg" width="100%"
  61. alt="Your OS scheduler — Task Scheduler, launchd or cron — or a cloud routine runs claude -p /seo-god daily at 05:00 local. The run keeps a fixed order: inputs (snapshot plus diff), regressions first (fix what fell), quick wins (positions 4-15), content gap (one new page at most), readout (a dated file on disk). It repeats tomorrow, and if no run marker appears for 48 hours the next /seo-god session opens with a warning.">
  62. </p>
  63. The order never changes: **inputs → regressions → quick wins → content gap → readout.**
  64. A quick win is worth nothing on a site that broke yesterday. A new page is worth even less.
  65. Unattended runs ask zero questions. A run that cannot reach OpenSEO degrades instead of guessing. It
  66. does what the available data supports, and it names what was missing in the readout.
  67. **The scheduled run edits files in your repository while you are not there.** Behind your own build
  68. gate. And it **never commits.** The changes wait in your working tree for you to review, next to a
  69. dated readout saying what it did and why.
  70. ## Install
  71. **macOS / Linux**
  72. ```bash
  73. git clone https://github.com/AKCodez/seo-god ~/.claude/skills/seo-god
  74. ```
  75. **Windows** — the same destination, `%USERPROFILE%\.claude\skills\seo-god`:
  76. ```powershell
  77. git clone https://github.com/AKCodez/seo-god "$env:USERPROFILE\.claude\skills\seo-god"
  78. ```
  79. Then open Claude Code in the repository of the site you want to work on, and type:
  80. ```
  81. /seo-god
  82. ```
  83. That is the whole install.
  84. The first run creates `seo-god.json` in that project: site URL, phase statuses, schedule mode. Every
  85. later run reads it and resumes where you stopped. Commit that file. It holds no keys, tokens or
  86. passwords.
  87. The `.seo-god/` directory created next to it is different. It goes into your `.gitignore` before
  88. anything is written into it, and it is never committed. That is where secrets, the run marker and
  89. local scratch live.
  90. ## What you need
  91. - **A website you own, and one that is publicly reachable.** Any stack. Repo access strongly preferred, because the fixes are edits in your repository, gated by your own build. The crawler is OpenSEO's and it blocks private and loopback targets with no override. So `localhost`, a `.local` name or a private IP cannot be audited. Put a public tunnel in front of a local site first (a `cloudflared` quick tunnel works), or point it at a deployed staging domain.
  92. - **Claude Code.**
  93. - **Docker** — Desktop on macOS and Windows, Engine plus Compose v2 on Linux. OpenSEO runs locally from a published image, and nothing is built from source.
  94. - **No paid API keys.** The free path is complete, end to end.
  95. One honest limit, and it is the rank numbers. Tracked keyword positions, search volume, keyword
  96. difficulty and backlink data all need the DataForSEO power-up below. Without it you measure from
  97. three free sources: your crawl, your own Search Console data, and the locked prompt set. Anything the
  98. skill could not measure is reported as *not measured*, never as zero.
  99. ## Power-ups
  100. <p align="center">
  101. <img src="./assets/readme/power-ups.svg" width="100%"
  102. alt="Three optional add-ons, and the free path is complete without them. DataForSEO adds real volume, difficulty and backlinks, and carries all three guards: a $0.50 per-run cap set by SEO_GOD_D4S_BUDGET_USD, a $2.00 balance floor, and a spend ledger. LLM API keys add direct model probing on the same locked prompts; they carry a per-run cap and a ledger, but no balance floor, because no provider exposes a balance — set a provider-side limit instead. The Telegram digest is outbound only and fires on completed runs; raising an alarm is deliberately not its job. No message means the run did not finish, and the 48-hour missed-run warning is the failure signal.">
  103. </p>
  104. All three are optional. They are offered in context, never assumed, and the skill is complete without
  105. them. Details in [references/power-ups.md](references/power-ups.md).
  106. | Power-up | | What it adds |
  107. | --- | --- | --- |
  108. | **DataForSEO** | optional | Real search volume, keyword difficulty and backlink summaries. Budget-capped before the first call by design: a `$0.50` default per-run cap (env-tunable), a `$2.00` balance floor that disables the paid plane outright, and a spend line in every readout that spent, or that ran with the paid plane disabled. |
  109. | **LLM API keys** | optional | Upgrades AI-visibility measurement from a search-results proxy to direct model probing — the same locked prompts, asked to the models themselves. |
  110. | **Telegram digest** | optional | The daily run ends with one plain-text message on your phone. Outbound only, and it fires only on runs that complete: no message means the run did not finish. |
  111. ## What it will never do
  112. <p align="center">
  113. <img src="./assets/readme/honesty-model.svg" width="100%"
  114. alt="Three columns. Measured, on the free path with no keys: crawl issues triaged by impact; Search Console queries, clicks and positions; search-results presence on ten locked prompts. Not measured, and reported as not measured rather than as zero: tracked rank positions, search volume and keyword difficulty, backlinks and referring domains — those need the DataForSEO power-up. Never claimed, with or without a key: that ChatGPT cited you, because the free number is a search-results proxy and not a citation; a zero standing in for missing data; a number with no source and no date.">
  115. </p>
  116. Hard rules, not guidelines. Every phase file is subordinate to them, and a phase that appears to
  117. conflict with one is required to stop and say so.
  118. - **Secrets stay in a gitignored env file** — `.seo-god/secrets.env`, gitignored at creation, never printed, never committed.
  119. - **Missing data is reported as missing**, never zero-filled and never extrapolated. Partial coverage is labelled partial.
  120. - **No bought links, no fake reviews, no auto-posting** to social or forums, and no fabricated claims on pages it writes. Directory submissions stay owner-driven.
  121. - **Any paid API path is budget-capped before the first call** — a per-run bound checked before the first call, a balance floor wherever the provider exposes a balance, and a spend ledger. No code path spends money with no cap in force, and raising the cap is yours alone to do. ([references/power-ups.md](references/power-ups.md) names which parts each provider supports. The LLM providers expose no balance endpoint, so that plane is capped and ledgered but has no floor.)
  122. - **No SERP scraping of Google**, anywhere in the skill, with or without a key.
  123. - **Scheduled runs come with failure visibility.** If no run marker appears for 48 hours, your next `/seo-god` session opens with that warning before anything else.
  124. - **It asks for the narrowest permissions that work.** For the turn it runs in, the skill requests `curl` (the local OpenSEO container is an HTTP API) and read-only `git`: `status`, `diff`, `log`, `check-ignore`, `rev-parse`. `git add`, `git commit` and `git push` are deliberately not among them. Nothing in this skill ever asks you to turn permission checks off wholesale.
  125. ## Tested on
  126. I built and verified this end to end on **Windows 11 + Git Bash**, driving real Docker (29.6.2,
  127. Compose v5.3.1) and a real OpenSEO container (0.1.3) against a live test fixture. A 7-page crawl. 10
  128. issue rows across 6 types. Both deliberately seeded defects found, triaged and fixed behind the build
  129. gate.
  130. The whole run is written up in **[docs/SMOKE.md](docs/SMOKE.md)**, including the parts that failed,
  131. with every finding marked fixed or still open. Read it before you trust this with a site.
  132. The macOS and Linux paths are stub-verified and written against documented behaviour. launchd, cron,
  133. the POSIX runner. None of them has been exercised on a real host yet.
  134. **Help wanted:** run it on macOS or Linux and open an issue with what happened, working or broken.
  135. That is the single most useful contribution to this repo right now.
  136. ## Uninstall
  137. Remove the schedule first if you installed one. The installer printed the command for your OS, and
  138. [references/schedule.md](references/schedule.md) carries all three: `Unregister-ScheduledTask` on
  139. Windows (§2.2), `launchctl bootout` **plus** deleting the plist on macOS (§2.3), and the
  140. `crontab -e` line on Linux (§2.4). Then delete the folder:
  141. ```bash
  142. rm -rf ~/.claude/skills/seo-god
  143. ```
  144. ```powershell
  145. Remove-Item -Recurse -Force "$env:USERPROFILE\.claude\skills\seo-god"
  146. ```
  147. `seo-god.json`, your snapshots and your readouts live in your own repository. Removing the skill
  148. leaves every one of them alone.
  149. ## Under the hood
  150. [`SKILL.md`](SKILL.md) is a thin orchestrator. It detects state, routes to exactly one phase file in
  151. [`references/`](references/), and loads that file only when the phase runs. The full design is in
  152. [docs/DESIGN.md](docs/DESIGN.md): every decision, what is deliberately out of scope, and the success
  153. criteria this was built against.
  154. The skill's description is the only thing that decides whether Claude Code loads it for a given
  155. request. So it was measured, not guessed. [docs/EVAL.md](docs/EVAL.md) is a 240-run triggering eval:
  156. the wording, the false-positive set, and the numbers it moved.
  157. Contributing: run `node scripts/skill-lint.mjs` before you open a PR. It checks the structural rules
  158. (SKILL.md's length and routing, every `references/*.md` reachable, both shell runners parsing) and
  159. exits non-zero on a violation.
  160. ## License
  161. [MIT](LICENSE)

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.