Most SEOs know that search engines understand entities (people, places, products, concepts) and the relationships between them. This isn’t new. It’s been baked into Google’s algorithms for years through patents on entity resolution, entity metrics, and dynamic entity definitions.

The problem isn’t awareness. It’s process.

When you sit down to plan content, how do you actually figure out which entities matter, how prominent each one should be, and how they relate to each other? Most people either skip it entirely or do it ad hoc, pulling from intuition and whatever they remember from the last article they read about semantic SEO.

I built a tool that turns this into a repeatable process. It’s a Claude skill, it’s free, and you can download it below.

What Entities Are (Brief Version)

When someone searches “best running shoes for flat feet,” Google doesn’t just match those words. It understands that “running shoes” is a product entity, “flat feet” is a medical condition entity, and the relationship between them is: shoes that address the condition.

Content that clearly establishes these entities and their relationships is easier for search engines to understand and match to queries. Entity analysis is how you figure out what those entities and relationships are before you write.

I’ve done other notes about entities in the past going into a lot more detail. You can find some of them here:

• A Simple Overview of Entities in SEO
• Semantic SEO Is Not a Theory
• What Is a Central Entity

What This Skill Does

Give it any topic or search query, and it runs a six-phase analysis:

1. Extracts all relevant entities. It tries to find every person, product, concept, condition, process, and metric connected to your topic, including implied ones
2. Identifies the central entity. The primary subject everything else orbits around. This is where most people go wrong. They confuse the context for the subject.
3. Classifies by importance. Primary, secondary, supporting, and contextual, with specific content placement guidance for each level
4. Scores salience. How prominent each entity should be in your content, on a 0-1 scale, with rationale
5. Validates entity recognition. Checks whether search engines actually recognize each entity (via Knowledge Panel presence, Wikipedia articles, and SERP features), so you know which ones need to be defined in your content
6. Maps relationships and co-occurrence. Builds Entity-Attribute-Value triples showing how entities connect, and maps which entities should appear together in the same sentences, sections, or pages

The output includes content placement recommendations: what belongs in your title, H1, H2s, first 100 words, and body copy. You get both a human-readable markdown report and a JSON version if you want to feed it into other tools.

What Are Claude Skills?

If you have not used them before, Skills are reusable instruction packages for Claude. Instead of writing a detailed prompt every time you want Claude to do something specific, a skill teaches it a workflow it can run consistently. Think of it as a playbook. You install it once, and Claude follows it automatically whenever you ask it to do that type of work.

Skills work in Claude.ai (web and app), Claude Code, and the API. You need a paid Claude plan (Pro, Max, Team, or Enterprise).

Claude Skills are one of the reasons I have moved almost completely away from ChatGPT. Other than images, when I need anything done in AI, Skills have made my workflows much faster and more efficient.

How to Install It

1. Download the .skill file: DOWNLOAD LINK
2. Open Claude.ai
3. Go to Settings → Capabilities
4. Scroll down to the Skills section and upload the file
5. Make sure the skill is toggled ON
6. Start a new chat

To use it, just give Claude a topic or search query and reference the skill. Something like:

• “Using the entity skill, analyze ‘best CRM for small business'”
• “Using the entity skill, extract entities for ‘symptoms of vitamin D deficiency'”
• “Using the entity skill, analyze electric vehicle charging infrastructure”

The skill handles the rest.

Note: You can tell it just to “run an entity analysis on ‘best CRM for small business'” and it will probably work fine. But if you have any other skills installed that mention entities, it could be a problem. Also, every now and then it won’t trigger the skill. Telling it specifically to use the skill has worked 100% of the time for me.

Sample Output

Here is a sample of what the output looks like. The prompt I gave it was:

Now I want to use the entity skill for the topic = [how to reduce lag on a minecraft server]

Entity Analysis: How to Reduce Lag on a Minecraft Server

Overview

• Input: how to reduce lag on a minecraft server
• Central Entity: Server Lag (Minecraft)
• Total Entities Extracted: 42
• Validation Coverage: 70% high confidence, 25% medium, 5% low

Central Entity

Entity: Server Lag (Minecraft)
Type: Concept/Problem
Definition: A delay or slowdown in the response time between player actions and server reactions in Minecraft multiplayer, manifesting as stuttering gameplay, block placement delays, mob teleportation, rubberbanding, and reduced server performance measured by TPS (Ticks Per Second) dropping below the optimal 20.
Validation: Medium — No dedicated Wikipedia article, but extensively documented in Minecraft Wiki, hosting provider documentation, and community resources. Component concepts “lag” and “latency” are high-confidence entities.

Why this is the Central Entity:

• Removal test: Without “lag,” the query has no problem to solve
• Relationship test: All other entities (causes, solutions, metrics) relate to this problem
• Query test: The searcher wants to understand and solve this specific problem
• Coverage test: The entire piece must address this concept

Entity Classification

Primary Entities

Secondary Entities

Supporting Entities

Contextual Entities

Attribute Analysis

Root Attributes (Cover all of these)

Rare Attributes (Cover for differentiation)

Unique Attributes (Cover for highest relevance)

Entity Relationships (EAV Triples)

Key Predicates

Use these verbs/actions in headings and content: reduces, causes, diagnoses, monitors, optimizes, allocates, limits, pre-generates, loads, processes, removes, configures, measures, identifies, improves

Co-Occurrence Map

High Priority (Same Sentence/Paragraph)

• Server lag + TPS — defining measurement
• TPS + 20 — optimal benchmark
• TPS + MSPT — related metrics
• entities + mobs + items — entity types causing lag
• Paper + Spigot — software comparison
• RAM + allocation + server — resource relationship
• view distance + chunks + loading — settings impact
• Spark + profiler + TPS — diagnostic tool chain

Medium Priority (Same Section)

• lag types + server + client + network — classification section
• entities + mob farms + kill commands — entity management section
• Paper + async + optimization — software benefits section
• hoppers + redstone + lighting — specific lag causes section
• plugins + Spark + profiling — diagnostic section
• RAM + garbage collection + JVM — memory optimization section
• chunks + pre-generation + Chunky — world optimization section

Document Level

• Server lag + Minecraft — topic context
• TPS + FPS — metric differentiation
• Spigot + Paper + Purpur — software hierarchy
• ClearLagg + Chunky + Spark — plugin/tool ecosystem

Validation Summary

High Confidence Entities (Use Freely)

• Minecraft (Wikipedia, Knowledge Panel)
• TPS/Ticks Per Second (Minecraft Wiki: “Tick” article)
• Chunks (Minecraft Wiki: “Chunk” article)
• Entities/Mobs (Minecraft Wiki: “Entity” articles)
• RAM, CPU (universal technical concepts)
• Latency/Ping (networking concepts, Wikipedia)
• Spigot (SpigotMC.org, extensive presence)
• Paper/PaperMC (GitHub, official site, 100k+ servers)
• Spark profiler (168M+ CurseForge downloads, GitHub)
• Redstone, Hoppers (Minecraft Wiki articles)
• FPS/Frames Per Second (universal concept)
• Optifine (major mod with Wikipedia mentions)
• Garbage Collection (Java/programming concept)

Medium Confidence Entities (Define on First Use)

• Server lag (compound concept, define clearly)
• MSPT (Minecraft-specific metric, define relationship to TPS)
• View distance / Simulation distance (server settings, explain function)
• Spawn chunks (Minecraft Wiki, but may need explanation for casual readers)
• ClearLagg (plugin, describe purpose)
• Chunky (plugin, describe purpose)
• JVM flags (technical, explain purpose)
• Pre-generation (process, explain benefit)
• Purpur, Folia (Paper forks, explain relationship)
• Aikars Flags (community term, needs definition)

Low Confidence Entities (Define Comprehensively)

• Rubberbanding (symptom description, informal term)
• Entity cramming (specific mechanic)
• Tick consolidation (advanced server concept)
• Async chunk loading (Paper-specific feature)

Content Recommendations

Title/H1 Must Include

• Lag or Server Lag (Central Entity problem)
• Minecraft Server (platform context)
• Consider modifier: “How to Reduce/Fix”, “Guide”, “[Year]”

H2 Topics (Based on Secondary Entities)

1. Understanding Minecraft Server Lag (TPS vs FPS vs Latency)
2. How to Check Your Server’s Performance (TPS, MSPT, Spark)
3. Common Causes of Server Lag
4. Reducing Entity Lag (Mobs, Items, Farms)
5. Optimizing Chunk Loading (View Distance, Simulation Distance, Pre-generation)
6. Choosing the Right Server Software (Vanilla vs Spigot vs Paper)
7. Plugin Optimization and Troubleshooting
8. RAM and JVM Configuration
9. Hardware Considerations

Entities to Define (First Mention)

• TPS: “Ticks Per Second measures how often your server updates game mechanics—20 TPS is healthy, anything below indicates lag”
• MSPT: “Milliseconds Per Tick shows how long each server update takes—must stay under 50ms to maintain 20 TPS”
• Chunks: “16×16 block sections of your world that the server loads and processes around players”
• Entities: “Movable game objects including mobs, dropped items, minecarts, and armor stands”
• Paper: “A high-performance fork of Spigot that includes numerous optimizations for Minecraft servers”
• Spark: “A performance profiling tool that helps identify what’s causing lag on your server”

Relationships to Emphasize

• TPS → measured as → 20 (optimal): “A healthy server runs at 20 TPS—each tick occurs every 50 milliseconds”
• Entities → cause → lag: “Large numbers of entities, especially in mob farms, force the server to track more movement and collision calculations”
• View distance → increases → chunk load: “Each point of view distance adds rings of chunks around every player, multiplying CPU and RAM usage”
• Paper → reduces → lag: “Paper’s optimizations include asynchronous chunk loading, hopper optimizations, and improved entity processing”
• Spark → identifies → lag sources: “Running a Spark profile for 30 seconds reveals which game mechanics or plugins consume the most processing time”

Analysis generated by The SEO Pub Entity Extraction Tool

I did not edit this output at all. As you can see, it is pretty in depth. Probably a lot more in depth than many of you are used to, but honestly if you implemented half of this, you would probably be ahead of 99% of your competitors.

Try It

Entity analysis has always been the gap between “I understand semantic SEO conceptually” and “I actually apply it to my content.” This skill closes that gap by giving you a structured, repeatable process you can run on any topic in a few minutes.

Download it. Run it on your next piece of content. See if it changes how you think about what belongs on the page and how to organize it.

Again, here is the .skill file: DOWNLOAD LINK