Skip to content

Checks

Cannibalization audit

Finds pages that compete for the same search intent, before you write a new page or across your whole library, and decides what to do with each.

Other tools

Add this skill to Claude

Claude takes skills as a ZIP file. Your download has started; if it didn't, use the button below.

  1. 1In Claude, open Customize, then Skills.
  2. 2Choose +, then Upload a skill, and pick cannibalization-audit.zip.
  3. 3Ask for it by name, or let Claude use it when a task matches.

Skills need code execution turned on in Claude's settings. On a Team or Enterprise plan, an admin can share it with everyone.

Download the folder

Try it now, without installing

See the skill work on a made-up input before you add it. Nothing is installed, and you can swap in your own input.

Open in the Claude app

Opens a new chat in the Claude desktop app with the prompt filled in. Nothing is sent until you press enter.

Includes the whole SKILL.md and the sample input. Paste it into Claude, ChatGPT or any chat.

Influenced by
Consolidating duplicate URLs
Needs
The planned page (for a new page) · Your site's pages, with URL, title and H1
Works with
Claude, ChatGPT, Codex, Cursor and any agent that reads SKILL.md
Version
2.0.0 · Last checked · License MIT
Maintained by
Sabih AhmedOrganic visibility
SkillSEO and AI search

Cannibalization audit

Example output

Audit the content library
PagesSeverityMove
Guide and definition postCriticalRedirect to guide
Pricing and pricing guideLowLeave, link
ROI for the CFONoneKeep

Finds pages that compete for the same search intent, before you write a new page or across your whole library, and decides what to do with each.

The skill

The whole skill, in plain text.

Nothing is hidden. Read it, change it to fit your team, or take the whole folder.

Scripts
Optional Python scripts for the counting. It works without them and says which way it ran.
Network
Opens web pages or your tools if your agent can. Works from pasted data if not.

3 test cases

cannibalization-audit/SKILL.md

In the folder

  • cannibalization-audit/SKILL.md
  • cannibalization-audit/scripts/clash_finder.py
---name: cannibalization-auditdescription: >-  Checks whether pages on a B2B SaaS site compete for the same search intent. Topic mode compares one planned page  with the site and returns PROCEED, DIFFERENTIATE, REFRESH or BLOCK. Library mode finds query-level clashes in  Search Console data, gives each group of competing pages a severity and a move (consolidate, redirect,  differentiate, leave) and returns PASS or FAIL. Use it before writing a page, or monthly across the library. Not  for choosing a keyword (use keyword-selection) or sorting pages by performance (use content-triage).license: MITcompatibility: >-  Works in Claude, ChatGPT, Codex, Cursor and any agent that reads SKILL.md. Uses a connected Search Console or a  crawl if the agent has one, otherwise exports or pasted lists. Python 3 is optional, for the clash finder.metadata:  author: SHAKEUP  version: "2.0.0"  stage: check  plugin: seo-ai-search  homepage: https://www.shakeuphq.com/skills/cannibalization-audit--- # Cannibalization audit Stops a site from competing with itself: before a new page is written, and across the pages already live. ## Purpose - One job: find pages that serve the same searcher need and say what to do about each clash.- Stage: check. It ends in a verdict with the rule that fired, and a severity per clash.- It judges intent, not words. 2 pages that share a keyword but serve different needs are not a clash.- It never redirects, merges or deletes anything. It writes the move; a person makes it. ## Use when / not | Situation | Use || --- | --- || A new page is planned and might repeat one you have | this skill, topic mode || Rankings bounce between 2 URLs, or the library grew without a plan | this skill, library mode || Choosing the keyword for a page | `keyword-selection` (run it first; its handoff feeds topic mode) || Deciding refresh, retire or protect by performance | `content-triage` (it reads this skill's clash groups) || Placing a cleared page in a cluster | `cluster-fit`, after a PROCEED or DIFFERENTIATE | ## Inputs | Input | Required | Ways to provide, in order | If missing || --- | --- | --- | --- || Mode | yes | the reader's request (a planned page means topic, an audit means library) | infer, say which || The planned page: topic, buyer, job (learn, compare, buy), primary keyword | topic mode | the `keyword-selection` handoff; the reader's request | ask once || The site's pages: URL, title, H1 | yes | a crawl or sitemap the agent can read; a crawl export (CSV); a pasted list | `NO VERDICT`, ask for it || Search Console, page and query rows, last 12 months | library mode; optional in topic mode | a connected Search Console; an export with both page and query columns; pasted rows | topic: health unknown, listed as a gap; library: group by title and H1 only, coverage `partial`, severity capped at moderate || Page modified dates | no | crawl metadata; sitemap `lastmod`; the date on the page | unknown counts as stale, listed as a gap || External links to candidate pages | no | a connected SEO tool; a backlinks export | any redirect move becomes a named stop | ## Profile read From `company-profile.md`: `## Company` (website, brand terms), `## Buyers` (who the pages are for), `## Content` (site sections, topic clusters), `## Accounts and data` (whether Search Console is connected), and every `## Learnings` entry for `cannibalization-audit` with status `noted`, `fact` or `accepted`. No profile: ask for the website and the brand terms (name, product names, common misspellings) in one message. Brand terms matter because branded queries are dropped before any clash is counted. Say that `company-profile` saves this next time. ## Steps 1. **Apply learnings.** Read them first. A learning that changes a threshold or a move overrides the default below; name it in the output when it fires. 2. **Pick the mode** and confirm the inputs it needs. Topic mode runs steps 3 to 8. Library mode runs steps 9 to 14. ### Topic mode 3. **Write the intent fingerprint** of the planned page in one sentence: "<buyer> who want to <learn | compare | buy> <the specific thing>, at the <awareness | consideration | decision> stage." Take the buyer from `## Buyers` and the job from the request or the `keyword-selection` handoff. 4. **Shortlist candidates** from the page list, at most 10. A page is a candidate when any of these hold:    | Signal | Threshold | Why |   | --- | --- | --- |   | Slug similarity to the keyword | 0.6 or more | close slugs usually mean a page someone already aimed at it |   | Word overlap with the title or H1 | 0.3 or more | a third of the words in common is a shared topic |   | Search Console impressions on matching queries | any | Google already tests this page for the need |   | Your read of the page | same need in other words | 2 pages can use different words for one need | 5. **Score each candidate 0 to 4** with the fingerprint questions. Each yes adds 1.    | Question | Yes when |   | --- | --- |   | Same buyer? | the page speaks to the same role and company type |   | Same need? | it answers the same core question |   | Same stage? | same job: learn, compare or buy |   | Would the searcher stop there? | someone who found it would not need the planned page |    4 is `OVERLAP`. 2 or 3 is `ADJACENT`. 0 or 1 is `NONE`. 6. **Check health for every OVERLAP page.** Healthy needs all 3; unknown is not healthy and goes in the data gaps.    | Test | Healthy when | Why |   | --- | --- | --- |   | Fresh | modified in the last 12 months | in a year, stats, tools and the live results move |   | Demand | 50 or more non-branded impressions on matching queries, 12 months | below 50 there is too little demand to say the page owns anything |   | Complete | it answers the fingerprint's core question in full (read it) | a thin page that ranks is a refresh, not a wall | 7. **Run the rules.** With Python, write the candidates to JSON and run:    ```   python3 scripts/clash_finder.py topic --json topic.json   ```    Without Python, apply the verdict table below in order, compute slug similarity by eye (same words in the same order counts as near-exact), and say you ran it by hand. 8. **Name the differentiation** for an ADJACENT result: the angle in one sentence (a narrower buyer, a different stage, a format the other page lacks) and the sibling URL the new page links to. If you can't name an angle a writer could hold for a whole page, there isn't one. ### Library mode 9. **Load the rows.** Drop branded queries (any brand term from the profile) and queries under 10 impressions in the window (noise). Report both counts. 10. **Find clashes.** For each query, list the pages that each take 10% or more of its impressions (below 10% is a brief test, not a clash). 2 or more such pages is a clash. Run:     ```    python3 scripts/clash_finder.py library --csv pages_queries.csv --brand "<brand term>"    ```     Without Python, sort the rows by query, compute each page's share of the query's impressions, and keep queries with 2 or more pages at 10% or more. Group pages that share any clash query. 11. **Confirm intent per group.** Write the fingerprint of each page in the group. The data shows a shared query, not a shared need: a pricing page and a guide can share "<category> pricing" and both be right. Different fingerprints drop the group to `low` and the move to leave. 12. **Set severity.**     | Severity | Condition (first match wins) | Why |    | --- | --- | --- |    | critical | same intent, 2 or more pages each at 20% or more of shared queries, 100 or more shared impressions | Google is alternating between them on real demand |    | moderate | same intent and 50 or more shared impressions; or same intent from titles and H1s with no Search Console data | the split is real but small, or unproven |    | low | different intent, or under 50 shared impressions | monitor; acting costs more than it wins | 13. **Pick the keeper and the move.** The keeper has the most clicks on the shared queries; ties go to more total clicks, then more external links, then the shorter URL.     | Condition (first match wins) | Move |    | --- | --- |    | Different intent | leave both; link them to each other |    | The other page's own (non-shared) queries show a distinct need, with 50 or more impressions | differentiate: re-aim it at that need, cut the overlapping sections, link to the keeper |    | Keeper has 2x or more the other page's clicks on shared queries (clearly stronger) | redirect the other page to the keeper (301), after moving any section the keeper lacks |    | Neither has 2x the other | consolidate: merge the best sections into the keeper, 301 the rest, then `refresh-audit` the keeper |     A query that is a narrower form of the same need ("<topic> definition" beside "<topic> guide") is not a distinct need. 14. **Check external links** before any redirect. A page with external links pointing at it is a named stop, whatever its traffic. ## Check and verdict Topic mode: | Verdict | Condition (first match wins) || --- | --- || `NO VERDICT` | No planned topic, or no page list after asking || `BLOCK` | An OVERLAP page is healthy: link to it, don't write a new page || `REFRESH` | OVERLAP pages exist and none is healthy: improve the strongest (consolidate if 2 or more) || `DIFFERENTIATE` | Best match is ADJACENT and an angle and a sibling URL are named; or no overlap but a near-exact slug or title match (0.9 or more) exists || `BLOCK` | Best match is ADJACENT and no distinct angle can be named || `PROCEED` | No candidate scores 2 or more | Library mode: | Verdict | Condition (first match wins) || --- | --- || `NO VERDICT` | No page list and no Search Console rows || `FAIL` | 1 or more critical groups || `PASS WITH NOTES` | Moderate or low groups only || `PASS` | No clashes | Named stops: every `REFRESH` that consolidates and every redirect or consolidate move waits for the reader to confirm the keeper (redirects move links and history). Any move on a page with external links stops for the reader. `NO VERDICT` asks for the missing input. No other stops. ## Learn Append a learning to the profile when: - the reader overrides a verdict or a move (write their reason as a `proposal`);- the reader reports what happened after a merge or redirect, such as clicks to the keeper 60 days later (a `fact`, with its source);- the reader marks a group as different intent that the rules called the same (a `proposal` to treat that page pair or page type as distinct). Example: `- 2026-10-24 | cannibalization-audit | proposal | Treat /pricing and /guides/<category>-pricing as different intent | Why: reader confirmed the guide brings demos the pricing page doesn't (CRM, Oct 2026) | Status: proposed` ## Output Topic mode: ```Verdict: <PROCEED | DIFFERENTIATE | REFRESH | BLOCK | NO VERDICT> · Coverage: <complete | partial (what's missing) | blocked> · Rules run: <script | by hand>Rule fired: <the condition, in words>Fingerprint: <one sentence> | Page | Score (0 to 4) | Class | Fresh | Demand (impressions) | Complete | Notes |(candidates, best first; "not available" where data is missing) Target page: <URL, or none>Angle (DIFFERENTIATE only): <one sentence> · Link to: <sibling URL>Data gaps: <list, or none>Learnings applied: <list, or none>``` Library mode: ```Verdict: <PASS | PASS WITH NOTES | FAIL | NO VERDICT> · Coverage: <...> · Rows: <n> in, <n> branded dropped, <n> low-volume queries droppedCounts: <n> critical, <n> moderate, <n> low | Group | Severity | Pages | Keeper | Shared queries | Shared impressions | Move | Why |(critical first) Redirects proposed: <from URL> to <keeper URL>, one per line, each marked "confirm"Learnings applied: <list, or none>``` Then the handoff block. ## Hand off ```handoffskill: cannibalization-auditversion: 2.0.0verdict: REFRESHcoverage: partial (no modified dates)for: <planned page, or "library audit">outputs:  mode: topic  target_url: https://example.com/blog/attribution-software  angle: not available  clash_groups: 0next: [refresh-audit]open: [confirm the keeper before any redirect]``` `next` by verdict: `PROCEED` and `DIFFERENTIATE` go to `[cluster-fit]`; `REFRESH` to `[refresh-audit]`; `BLOCK` to `[internal-linking]` (link to the page that owns the intent); library mode to `[content-triage]`, with `clash_groups` and each keeper listed in `outputs`. ## Failure modes | Problem | Do this || --- | --- || The Search Console export has no page column (queries only) | Library mode can't find clashes from it. Ask for the page and query export; meanwhile group by title and H1, coverage `partial` || Every query looks branded because the brand is a common word | Use the full brand terms from the profile only, and list the queries you kept || A clash is between a page and its own URL with parameters or a trailing slash | Not a clash: a canonical problem. Report it as one and point to `agent-readiness` || The site has thousands of pages | Library mode on the script; topic mode on the 10 best candidates only || The reader wants a page written anyway after BLOCK | Record the override as a learning and hand the angle question to `keyword-selection` || Two pages target different countries or languages | Not a clash if each serves its own region; check hreflang instead | ## Influenced by - SHAKEUP's content engine: verdicts from ordered rules anchored on intent, page health read from freshness, demand and completeness, and a near-exact match that can never pass as new.- Google's guidance on consolidating duplicate URLs, which explains how redirects and canonicals pass signals to one page: https://developers.google.com/search/docs/crawling-indexing/consolidate-duplicate-urls

How it thinks

Inputs in, a verdict out, and a stop only where you decide.

What we built

We compare pages on the need they serve, scored with 4 questions, so a pricing page and a pricing guide never get merged for sharing a query. A page only blocks a new one when the data shows it's fresh, in demand and complete.

It reads your company profile if you have one, or asks for only what it needs. Then it works through its steps, checks its own work and ends in a verdict.

The steps

  1. 01

    Read your learnings first

    Page pairs your team already marked as different intent stay apart, and any threshold you changed applies before it starts.

  2. 02

    Write the intent fingerprint

    One sentence per page on who it serves, what they want to do and at which stage. Pages are compared on that, not on shared words.

  3. 03

    Score each candidate against 4 questions

    Same buyer, same need, same stage, and would the searcher stop there. 4 yes answers is an overlap, 2 or 3 is adjacent.

  4. 04

    Check the health of any page that overlaps

    A page modified in the last year, with 50 or more non-branded impressions and a full answer, owns the intent. Anything unknown counts against it.

  5. 05

    Find query clashes across the library

    Its script flags queries where 2 or more pages each take 10% or more of the impressions, after dropping branded queries.

  6. 06

    Pick the keeper and the move

    The page with the most clicks on the shared queries stays. Every other page is merged, redirected or re-aimed, and each redirect waits for your yes.

What you need

  • Required

    The planned page (for a new page)

    The handoff from keyword selection → Your request, with the buyer, the job and the keyword

  • Required

    Your site's pages, with URL, title and H1

    It reads your sitemap or crawl if your agent can browse → A crawl export you upload → A list you paste

  • Optional

    Search Console rows by page and query, last 12 months

    A connected Search Console → An export with both page and query columns → Rows you paste

  • Optional

    Page modified dates

    Your crawl or sitemap → The date shown on each page

  • Optional

    Links from other sites to the pages in a clash

    A connected SEO tool → A backlinks export

What it can return

  • PROCEED

    No page on your site serves the same need. Write the new page.

  • DIFFERENTIATE

    A page is close, and a distinct angle and a page to link to are named.

  • REFRESH

    A page already serves the need but isn't confirmed healthy. Improve it instead of writing a new one.

  • BLOCK

    A healthy page already owns the need, or a close page exists and no distinct angle can be named.

  • FAIL

    In a library audit, at least 1 group of pages is splitting real demand for the same need.

  • PASS

    In a library audit, no group is critical. Minor clashes are listed to watch.

  • NO VERDICT

    There's no list of your pages to compare against.

Where it stops for you

  • Before any redirect or merge, to confirm which page stays
  • When a page in a clash has links from other sites

Example output

What you get back.

A run for a made-up company. Your output depends on your inputs.

Here's a library audit for a made-up B2B SaaS company that sells attribution software. It pasted 12 months of Search Console rows by page and query.

Verdict

FAIL

Coverage: partial (no backlink data)

Rows: 10 in, 2 branded dropped

PagesSeverityKeeperShared impressionsMoveWhy
/blog/pipeline-attribution-guide, /blog/what-is-pipeline-attributionCriticalThe guide4,000Redirect the definition post to the guide, after moving its definition sectionSame buyer, need and stage, and the guide has 53 clicks on the shared queries to 24
/pricing, /guides/how-attribution-tools-priceLowBoth stay1,050Leave both, link them to each otherA pricing page and a guide to how tools price serve different needs
Redirect proposed

/blog/what-is-pipeline-attribution to /blog/pipeline-attribution-guide. Confirm before anyone makes it.

The handoff block the next skill reads
skill: cannibalization-audit
version: 2.0.0
verdict: FAIL
coverage: partial (no backlink data)
for: library audit
outputs:
  mode: library
  clash_groups: 1
  keeper: /blog/pipeline-attribution-guide
next: [content-triage]
open: [confirm the redirect]

What good looks like

  • Every clash names one page that stays and a move for the others
  • Pages that serve different needs are left alone, even when they share a query
  • Branded queries are dropped before anything is counted
  • Redirects name the URL they come from and go to, each marked for you to confirm
  • No traffic or link figures that weren't in your data

Install

Use it in the tool you already have.

Pick your tool. Each tab has the shortest path we know of.

  1. 01
  2. 02
    In Claude, open Customize, then Skills.
  3. 03
    Choose +, then Upload a skill, and pick the ZIP. Code execution must be on in your settings.
  4. 04
    Ask for it by name, or let Claude use it when a task matches.

Questions

Before you add it.

Does it need Search Console?

For a library audit it works best with page and query rows. Without them it groups pages by title and H1, caps severity at moderate and says the result is partial.

Will it merge pages that share a keyword?

Only when they serve the same need. It writes a fingerprint for each page first, so a pricing page and a guide about pricing stay separate even when they share queries.

Does it change anything on my site?

No. It writes the move and the redirect map. Every redirect or merge waits for you to confirm the page that stays.

What does the script do?

It finds queries where 2 or more pages each take 10% or more of the impressions, groups those pages and picks the keeper by clicks. Without Python, the skill makes the same count itself and says so.