What are Claude Skills

If you have spent any time building prompts for SEO work, you know the pain of re-explaining context every session. You open Claude, paste in the same system instructions you used last Tuesday, adjust them because you forgot a detail, and then start the actual work. Claude Skills solve this by packaging your instructions into a persistent, reusable module that lives as a file on disk.

A Claude Skill is a folder containing a SKILL.md file. That file has two parts: YAML frontmatter that defines metadata (name, description, trigger conditions, slash command) and markdown instructions that tell Claude exactly what to do when the skill is invoked. Anthropic launched Skills on claude.ai in October 2025 and released the open skills standard in December 2025, which means the same SKILL.md file works across Claude Code, Cursor, Codex, Windsurf, and over 35 other AI agents that have adopted the standard.

For SEO practitioners, this matters because it turns your best prompting work into infrastructure. Instead of a prompt that lives in a Google Doc or a Notion page, you have a versioned file you can commit to Git, share across your team, and invoke with a single slash command like /keyword-research or /content-audit. The skill carries all the context: what data to expect, what format to output, what edge cases to handle, and what rules to follow. If you have been using Claude for SEO optimization work, skills are the natural next step for making those workflows repeatable.

There are no character limits on the instructions inside a SKILL.md file. This is worth emphasizing because it is a meaningful difference from alternatives. If your content audit skill needs 5,000 words of detailed instructions covering every edge case for your specific CMS, page templates, and scoring criteria, you write all 5,000 words. The skill can also reference other files in its folder, so you can include example outputs, scoring rubrics, or template files alongside the instructions.

Claude Skills vs Custom GPTs vs Custom Instructions

Before diving into the SEO use cases, it helps to understand where Skills sit relative to the other customization approaches available. The differences are not just cosmetic. They affect how you build, maintain, and distribute your SEO workflows.

The practical implication: if you build an SEO skill as a SKILL.md file, every team member using Claude Code, Cursor, or any other agent that supports the open standard can use it immediately. You push the skill to your team's Git repo and it is available everywhere. No one needs to recreate the prompt from memory or copy it from a shared document. When someone improves the skill, the improvement propagates through a normal Git pull.

Custom GPTs serve a different purpose. They are good for packaging a specific workflow behind a simple interface for non-technical users. But for SEO teams that already work in code editors and terminals, the file-based approach is more natural and far more maintainable. If you are currently managing SEO workflows across multiple tools, our guide on automated SEO workflows covers the broader automation architecture that skills plug into.

Anatomy of a SKILL.md file

Before we get into the SEO-specific skills, here is the structure of a SKILL.md file. Understanding this format is essential because every skill you build or customize follows it.

---
name: keyword-research
description: Clusters raw keyword lists by search intent and topical relevance
version: 1.2.0
triggers:
  - slash: /keyword-research
  - context: "keyword list|keyword data|search terms"
author: seo-team
tags:
  - seo
  - keywords
  - clustering
---

# Keyword Research and Clustering Skill

## Input expectations
You will receive a list of keywords, typically exported from Google Search
Console, Ahrefs, or a similar tool. The list may include columns for:
- Keyword (required)
- Search volume (optional)
- Current ranking position (optional)
- Click-through rate (optional)
- Landing page URL (optional)

## Process
1. Parse the keyword list and normalize formatting
2. Classify each keyword by search intent:
   - Informational: user wants to learn something
   - Commercial investigation: user is comparing options
   - Transactional: user is ready to buy or sign up
   - Navigational: user is looking for a specific site
3. Group keywords into topical clusters based on semantic similarity
4. For each cluster, identify:
   - The primary keyword (highest volume or most relevant)
   - Supporting keywords that should appear on the same page
   - Keywords that deserve their own dedicated page
5. Flag cannibalization risks where multiple existing pages target
   the same cluster

## Output format
Return a structured table with columns:
| Cluster Name | Primary Keyword | Supporting Keywords | Intent | Recommended Page | Cannibalization Risk |

## Rules
- Never invent search volume numbers. If volume data is not provided,
  say "volume not provided" rather than estimating.
- If a keyword could belong to multiple clusters, assign it to the
  most specific one and note the secondary cluster.
- Flag any keyword where intent is ambiguous and explain why.
- Do not merge clusters that target genuinely different user needs,
  even if the keywords look similar on the surface.

The frontmatter between the --- delimiters defines when and how the skill activates. The triggers field is particularly useful: it lets you define both explicit slash commands and context-based triggers. In the example above, the skill activates automatically whenever the conversation mentions "keyword list," "keyword data," or "search terms." This means you do not always need to remember the exact slash command. You paste in a keyword export and the skill recognizes the context.

The markdown body below the frontmatter is the actual instruction set. This is where you specify input expectations, the step-by-step process, output format, and guardrails. There is no limit on how detailed this can be. A well-built SEO skill includes edge cases, examples of good and bad output, and explicit rules about what the skill should never do (like fabricating data).

Keyword research and clustering

The SKILL.md example above is a real keyword clustering skill we use. Here is how it works in practice and why the skill format matters more than a simple prompt.

When you export 500 keywords from Google Search Console and paste them into a Claude conversation with this skill active, the skill provides all the context Claude needs without you writing any instructions. It knows to look for volume data, to classify intent using a four-category system rather than making up its own, to group by semantic similarity rather than just lexical overlap, and to flag cannibalization. Without the skill, you would need to re-explain all of this every time.

The skill format also lets you include reference files. In our keyword clustering skill folder, we include a intent-examples.csv file with 50 pre-classified keywords that serve as few-shot examples. Claude reads this file when the skill activates and uses it to calibrate its intent classification. The result is noticeably more consistent than when you rely on Claude's general knowledge alone.

Customizing for your niche

The generic skill above works for general keyword clustering, but the real value comes from customizing it for your specific domain. If you run an ecommerce site, you add instructions about product-category mapping, purchase intent signals, and how to handle branded vs. unbranded terms. If you work in B2B SaaS, you add instructions about funnel stage classification, buyer persona mapping, and how to distinguish between developer keywords and decision-maker keywords. The skill file is where your team's specific knowledge lives, and it compounds over time as you refine it. For more depth on how we approach content strategy, that page covers the broader framework these skills plug into.

Content audit and optimization

A content audit skill is probably the highest-value SEO skill you can build, because content auditing is time-intensive, repetitive enough to standardize, and requires enough judgment that a well-structured prompt dramatically improves output quality.

Our content audit skill takes a page URL (or the full HTML content), the target keyword, the page's current Search Console performance data, and optionally the top three competitor pages for that keyword. It then runs a structured evaluation covering:

• Title tag and meta description analysis: Is the keyword present? Is the title within character limits? Does the meta description include a call to action?
• Heading structure: Does the H1 match the target keyword? Are H2s covering the subtopics that ranking competitors address?
• Content depth: What subtopics do competitors cover that this page does not? Are there sections that are thin relative to the competition?
• Internal linking: Does the page link to other relevant pages on the site? Are there obvious internal linking opportunities being missed?
• E-E-A-T signals: Does the content demonstrate experience, expertise, authoritativeness, and trustworthiness? Are claims supported with data or citations?
• Technical elements: Is schema markup present? Are images optimized with descriptive alt text? Is the content properly structured for featured snippets?

The skill outputs a scored report with a prioritized list of specific changes. Not vague recommendations like "improve content quality," but concrete items like "Add a section on implementation costs between sections 3 and 4, which all three competitors cover and this page does not" or "The title tag is 68 characters. Shorten to under 60 to prevent truncation. Suggested: [specific title]."

---
name: content-audit
description: Audits a page against target keyword and competitors
version: 2.0.1
triggers:
  - slash: /content-audit
  - context: "audit this page|content audit|page review"
tags:
  - seo
  - content
  - audit
---

# Content Audit Skill

## Required inputs
1. Page content (URL or full HTML)
2. Target keyword
3. Current GSC data: impressions, clicks, CTR, avg position (if available)

## Optional inputs
- Top 3 competitor page contents or URLs
- Target word count range
- Specific CMS constraints (e.g., "no H4 tags" or "max 3 images")

## Scoring categories (1-10 each)
- Keyword targeting (title, H1, URL, first 100 words)
- Content depth (subtopic coverage vs. competitors)
- Heading structure (logical hierarchy, keyword inclusion)
- Internal linking (quantity and relevance)
- E-E-A-T signals (experience, data, citations)
- Technical SEO (schema, alt text, structured data)

## Output format
### Summary
Overall score: X/60
Priority fixes: [top 3 items that will have the most impact]

### Detailed analysis
[Section-by-section breakdown with specific recommendations]

### Content gap analysis
[Topics competitors cover that this page does not]

## Rules
- Never say "the content is good" without specifics
- Every recommendation must include a concrete action
- If competitor data is not provided, note what analysis
  is limited without it rather than guessing
- Flag any thin sections (under 100 words on a subtopic
  that competitors cover in 300+)

Schema markup generation

Schema generation is one of the most natural fits for a Claude Skill because the task is highly structured, the output format is well-defined, and the rules are documented in the schema.org specification. A schema skill eliminates the most common errors: missing required properties, incorrect nesting, and type mismatches.

Our schema generation skill handles Article, FAQPage, HowTo, Product, LocalBusiness, BreadcrumbList, and WebApplication types. It reads the page content, identifies which schema types are appropriate, and generates valid JSON-LD. The skill includes explicit rules about required vs. recommended properties for each type, which prevents Claude from generating schema that technically validates but misses properties that Google actually uses for rich results.

The key detail that makes this skill better than a generic prompt: it includes a schema-rules.md reference file in the skill folder that documents Google's actual requirements (not just schema.org's), including the properties that trigger rich results, the content policies for FAQ schema, and the common validation errors that Google Search Console reports. This reference file gets updated quarterly as Google changes its requirements. For a deeper look at how we handle technical SEO at scale, that service page outlines our full approach.

---
name: schema-generator
description: Generates validated JSON-LD schema markup for any page type
version: 1.4.0
triggers:
  - slash: /schema
  - context: "schema markup|json-ld|structured data|rich results"
tags:
  - seo
  - schema
  - technical
---

# Schema Markup Generation

## Process
1. Read the page content provided
2. Determine appropriate schema type(s)
3. Extract relevant data from the content
4. Generate JSON-LD following Google's requirements (not just schema.org)
5. Validate the output structure before returning

## Supported types
- Article / BlogPosting / NewsArticle
- FAQPage (with Question/Answer pairs)
- HowTo (with step-by-step structure)
- Product (with offers, reviews, pricing)
- BreadcrumbList
- WebApplication / SoftwareApplication
- LocalBusiness / Organization
- Service

## Rules
- Always include @context and @type
- Use Google's required properties, not just schema.org recommended
- For FAQPage: minimum 3 questions, maximum 10
- For HowTo: each step must have name and text
- Never fabricate review counts, ratings, or pricing
- Output raw JSON-LD wrapped in <script type="application/ld+json">
- Validate nesting: no orphaned properties outside their parent type

Technical SEO automation skills

Technical SEO is where Claude Skills combine with Claude Code to become genuinely powerful. A skill running in Claude Code does not just analyze data. It can read your file system, parse crawl exports, generate redirect maps, and write fixes directly to your codebase. The skill provides the instructions and guardrails; Claude Code provides the execution environment.

Crawl analysis skill

This skill ingests a Screaming Frog export (or any crawler CSV) and produces a prioritized issues report. It knows which columns to look for, how to categorize issues by severity, and how to calculate the potential traffic impact of each fix using Search Console data. The skill explicitly tells Claude to compare the current crawl against a baseline (previous crawl export, also in the folder) and highlight only new or worsening issues. This is critical for weekly monitoring because you do not want to re-triage issues you already know about.

Redirect mapping skill

Site migrations are one of the highest-risk SEO operations, and redirect mapping is the most error-prone part. Our redirect skill takes a list of old URLs and new URLs, validates that every old URL has a destination, flags redirect chains longer than two hops, identifies loops, and checks that the destination page is semantically related to the source. It outputs a clean redirect map in the format your server expects (Apache .htaccess, Nginx conf, Cloudflare rules, or Next.js redirects in next.config). The skill includes rules about preserving query parameters, handling trailing slashes, and flagging any old URL that had significant organic traffic but is being redirected to a generic page rather than a topically matched destination.

Meta tag auditing skill

This skill reads your site's page files (or a crawl export) and audits every title tag, meta description, canonical tag, and robots directive. It checks for duplicates across pages, flags titles that are too long or too short, identifies meta descriptions that are missing or duplicate, validates that canonical tags point to valid URLs, and ensures robots directives are not accidentally blocking important pages. In Claude Code, this skill can also fix the issues it finds, writing corrected meta tags directly to your source files. This is where the pattern described in our automated SEO workflows guide intersects with skills: the skill defines the rules, Claude Code executes them, and you review the diff before committing.

Competitor analysis

Competitor analysis is one of those tasks that every SEO team does but few do systematically. Most competitor analysis is ad hoc: you look at a competitor's page when you happen to think of it, note a few things, and move on. A skill turns this into a structured, repeatable process.

Our competitor analysis skill takes a target keyword and the content from the top-ranking pages (you paste in the text or provide URLs if Claude has web access). It then produces:

• Heading structure comparison: What H2 and H3 topics does each competitor cover? What is common across all top pages (table stakes content) and what is unique to each?
• Content format analysis: Is the winning format a how-to guide, a comparison table, a listicle, or a deep-dive editorial? How long are the top pages?
• Internal linking patterns: What related topics do competitors link to? This reveals their content architecture and the topics they consider semantically adjacent.
• Content freshness signals: When were competing pages last updated? Do they include dates, version numbers, or other freshness indicators?
• Differentiation opportunities: Based on the analysis, what angles are underserved? Where can your page add information or perspective that none of the current results provide?

The output is a structured brief that feeds directly into content creation. This is a concrete example of skill chaining, which we cover below: the competitor analysis skill's output becomes the input for the content brief generation skill.

Content brief generation

Content briefs are the bridge between SEO strategy and actual content production. A brief skill takes the target keyword, the keyword cluster it belongs to, competitor analysis data, and any specific business context, then produces a detailed brief that a writer (human or AI) can execute against.

Our content brief skill generates:

• Target keyword and secondary keywords to include
• Recommended title tag and meta description
• H2 and H3 heading outline with guidance on what each section should cover
• Word count target based on competitor analysis
• Internal linking targets (pages on your site to link to and from)
• Schema types to implement
• Specific differentiators: what this page should cover that competitors miss
• Sources and data points to include for E-E-A-T

The skill includes rules about not padding briefs with generic advice. Every item in the brief must be actionable and specific to this keyword. "Include relevant statistics" is not acceptable output. "Include the 2025 conversion rate benchmark from the Unbounce report (14.3% for SaaS landing pages)" is. This level of specificity is only possible because the skill instructions can be as detailed as needed. In an 8,000-character Custom GPT, you cannot fit this kind of nuance.

Internal linking optimization

Internal linking is one of the most impactful and most neglected parts of on-page SEO. Most sites have significant internal linking gaps because no one systematically audits them. A Claude Skill makes this tractable.

The internal linking skill takes two inputs: a sitemap or list of all pages on your site (with their primary keywords and titles), and the content of a specific page you want to optimize. It then:

• Identifies every topically relevant page that the current page should link to but does not
• Suggests specific anchor text for each link, using the target page's primary keyword naturally
• Identifies where in the content each link should be placed (referencing the surrounding sentence)
• Flags over-linking: if the page already has too many internal links, it recommends which to keep and which to remove
• Identifies orphan pages: pages in your sitemap that are not linked to from any of the pages analyzed in this session

In Claude Code, this skill can go further. It can read your entire site's source files, build an internal link graph, and identify the pages with the weakest internal link profiles. Then it can write the links directly into your content files. You review the diff, approve the changes, and commit. What used to take a day of manual work becomes a 20-minute review session. For more on how we approach this systematically, see our AIO optimization service.

Chaining skills into a complete SEO workflow

Individual skills are useful. Chained skills are where the real leverage appears. Skill chaining means the output of one skill becomes the input for the next, creating a multi-step pipeline from modular components.

Here is a concrete workflow we run monthly for content planning:

Step 1: Keyword research skill. Input: raw keyword export from Search Console (3 months of query data). Output: clustered keywords with intent classification, organized by topic.

Step 2: Competitor analysis skill. Input: the top keyword from each new cluster identified in step 1. Output: structured analysis of what the top-ranking pages cover for each keyword.

Step 3: Content brief skill. Input: the cluster data from step 1 and the competitor analysis from step 2. Output: a detailed brief for each new page or page update needed.

Step 4: Schema generation skill. Input: the heading structure and content type from each brief. Output: pre-built JSON-LD schema that gets implemented alongside the content.

Step 5: Internal linking skill. Input: the new pages from the briefs plus your existing sitemap. Output: a linking plan that integrates the new content into your site's link architecture.

Each step produces structured output that the next step can consume. You can run this pipeline manually (invoking each skill in sequence) or set it up in Claude Code as a single command that runs the full chain. The key advantage over doing this with standalone prompts: each skill carries its own context, rules, and guardrails. The competitor analysis skill does not need you to re-explain what format its output should take. The content brief skill does not need you to remind it to include internal linking targets. Every module does its job correctly because its instructions are persistent and complete.

# Example: Running a chained workflow in Claude Code

# Step 1 - Cluster this month's keywords
/keyword-research
[paste GSC export]

# Step 2 - Analyze competitors for top clusters
/competitor-analysis
Target keyword: "ai seo automation tools"
[paste top 3 competitor page contents]

# Step 3 - Generate brief from cluster + competitor data
/content-brief
Keyword cluster: [output from step 1]
Competitor analysis: [output from step 2]

# Step 4 - Pre-generate schema for the brief
/schema
Page type: Article
Content outline: [heading structure from step 3]

# Step 5 - Plan internal links for new content
/internal-links
New page: [title and primary keyword from step 3]
Sitemap: [existing sitemap.xml]

Building your first SEO skill: step by step

If you have never built a Claude Skill before, here is the process from start to finish. We will build a title tag optimization skill as the example because it is simple enough to complete in 15 minutes but practical enough to use immediately.

Step 1: Create the skill folder

Create a new folder in your project directory. The folder name should match the skill name. Inside, create a file called SKILL.md.

mkdir title-tag-optimizer
touch title-tag-optimizer/SKILL.md

Step 2: Write the frontmatter

The frontmatter defines the skill's identity and trigger conditions. Keep the name short and descriptive. The triggers should cover both the explicit slash command and the context patterns that suggest this skill is relevant.

---
name: title-tag-optimizer
description: Audits and rewrites title tags for SEO performance
version: 1.0.0
triggers:
  - slash: /title-tags
  - context: "title tag|title tags|page titles|meta title"
tags:
  - seo
  - on-page
  - title-tags
---

Step 3: Write the instructions

This is where most of the work happens. Good skill instructions cover four things: what input to expect, what process to follow, what output to produce, and what rules to enforce. Be as specific as possible. Vague instructions produce vague output.

# Title Tag Optimizer

## Input
A list of pages with their current title tags and target keywords.
Format: URL | Current Title | Target Keyword

Optional: Search Console CTR data for each page.

## Process
1. Evaluate each title tag against these criteria:
   - Length: 50-60 characters (flag if outside this range)
   - Keyword placement: target keyword should appear in first 40 chars
   - Brand: consistent brand suffix format across all pages
   - Uniqueness: no duplicate titles across the set
   - Click appeal: does the title create curiosity or promise value?
2. For titles that need improvement, generate 2-3 alternatives
3. If CTR data is provided, prioritize pages with high impressions
   but below-average CTR (these have the most upside)

## Output format
| URL | Current Title | Issue | Recommended Title | Expected Impact |

## Rules
- Keep all titles under 60 characters including spaces
- Never use ALL CAPS or excessive punctuation
- Do not keyword-stuff. One primary keyword per title.
- Preserve existing brand format (e.g., "| Brand Name" suffix)
- If the current title is already strong, say so. Do not
  change titles just for the sake of change.

Step 4: Add reference files (optional)

If your skill benefits from examples, add them to the folder. For the title tag skill, you might include a good-titles.csv file with examples of high-CTR titles from your own data. Claude reads these files when the skill activates and uses them as calibration.

Step 5: Test and iterate

Load the skill in Claude Code (it detects it automatically from the folder) or upload it as a ZIP to claude.ai. Run it against real data. The first version of any skill will have gaps. You will discover edge cases your instructions did not cover, output format issues, or rules that are too strict or too loose. Edit the SKILL.md file, test again, and commit the improved version. This iterative process is exactly why the file-based format works better than a UI form: you edit a text file, you see the diff, and your version history is clean.

Where to find pre-built SEO skills

You do not need to build everything from scratch. The open skills standard has enabled a growing ecosystem of shared skills that you can download, customize, and use immediately.

GitHub

Search GitHub for "claude skills seo" or "skill.md seo" to find repositories with curated skill collections. Many SEO practitioners and agencies have open-sourced their skill libraries. Look for repositories with recent commits and clear documentation. The best ones include example inputs and outputs so you can evaluate quality before adopting them.

claudeskills.info

This community-maintained directory indexes Claude Skills across categories, including a growing SEO section. You can browse by use case, see ratings from other users, and download skills as ZIP files ready to use. It is the closest thing to an app store for the open skills ecosystem, but built on open files rather than proprietary packages.

Your own team

The most valuable skills are often the ones your team builds internally, because they encode your specific processes, your CMS constraints, your client reporting format, and your quality standards. We recommend starting with a few pre-built skills to understand the format, then progressively building custom skills for the workflows that are unique to your operation. Over time, your skill library becomes a codified version of your team's SEO methodology.

Adapting skills for your stack

Most pre-built skills need customization. An off-the-shelf schema generation skill will not know that your CMS requires a specific JSON-LD injection method, or that your client needs Organization schema on every page because of their brand guidelines. Treat pre-built skills as starting points. Fork them, edit the instructions, add your rules, and commit your customized version. The file-based format makes this trivial. You are just editing a markdown file.

Rank tracking and reporting automation

Reporting is one of those tasks that consumes disproportionate time relative to its strategic value. A reporting skill does not replace your rank tracking tool, but it can automate the interpretation layer: taking raw data and turning it into a narrative that clients or stakeholders can act on.

Our reporting skill takes a weekly Search Console data export (queries, impressions, clicks, position, CTR) and produces:

• Movement summary: Keywords that moved up or down more than 3 positions, grouped by direction and magnitude
• Opportunity identification: Keywords ranking 4-15 that have high impressions and could move to page one with targeted optimization
• Cannibalization detection: Keywords where multiple pages are competing, with a recommendation for which page should be the primary target
• CTR anomalies: Pages with unusually low CTR for their position, which suggests title tag or meta description issues
• Trend analysis: Week-over-week and month-over-month trends for core keyword groups

The skill formats this as a report with executive summary, detailed data tables, and specific recommended actions. The output is ready to paste into a client report or Slack channel. What used to take 2-3 hours of manual analysis per client now takes a 10-minute review of the skill's output.

Practical considerations and limitations

Skills are not a silver bullet, and being honest about their limitations will save you time.

Skills do not replace domain expertise. A keyword clustering skill is only as good as its instructions, and writing good instructions requires you to already know how keyword clustering should work. Skills codify expertise; they do not generate it. If your team does not have strong SEO fundamentals, skills will just automate mediocre processes faster.

Skills need maintenance. Google changes its schema requirements. Search Console updates its API response format. Your CMS adds new page types. Skills that reference specific data formats or platform behaviors need periodic updates. Treat your skill library like code: schedule quarterly reviews and update anything that has drifted.

Output still requires validation. Even with detailed instructions and guardrails, Claude can produce output that looks correct but contains subtle errors. Schema markup might use a property that schema.org supports but Google does not use for rich results. A redirect map might miss a query parameter edge case. A content brief might include an internal link to a page that no longer exists. Human review remains non-negotiable for anything going to production. The skill makes the human reviewer faster, not unnecessary.

Context window limits still apply. A skill's instructions consume part of the context window. If your content audit skill is 3,000 words of instructions and you are also pasting in 5 competitor pages, you may approach context limits on smaller models. Be concise in your skill instructions. If a rule can be stated in one sentence, do not use three. Reserve context window space for the actual data the skill needs to process.

Not all agents support all features. While 35+ agents support the open skills standard, the depth of support varies. Claude Code has the deepest integration (file system access, script execution, auto-detection). Other agents may support the slash command and instruction reading but not the reference file loading or auto-triggering. Test your skills in each environment you plan to use them in.

Frequently Asked Questions