seo-review

Name: seo-review
Author: leonardomso

Security Community

Repo stars 66,469
Author updated Live
Author repo 33-js-concepts

Fluxly profile Facts only: domain, agents, trust score, runtime, permissions and network

Domain: Security
Compatible agents: Claude Code
Cursor
Cline
Codex
Windsurf
Gemini CLI

+20
Trust score: 88 / 100 · community maintained
Author / version / license: @leonardomso · no license declared
Token usage: Heavy
Setup complexity: Guided setup
External API key: Not required
Operating systems: Unspecified (assume cross-platform)
Runtime requirements: No special requirements
Permissions: Read-only
Write / modify
Shell exec
Network behavior: Local-only
Install commands: 26 variants

Profile is derived at build time from SKILL.md and install vectors. Subject to drift from author intent.

Heads up: 未限定 allowed-tools，默认拥有全部工具权限。

Output preview seo-review.preview

---
name: seo-review
description: Perform a focused SEO audit on JavaScript concept pages to maximize search visibility, featured…
category: security
runtime: no special runtime
---

# seo-review output preview

## PART A: Task fit
- Use case: Perform a focused SEO audit on JavaScript concept pages to maximize search visibility, featured snippet optimization, and ranking potential Use this skill to perform a focused SEO audit on concept documentation pages for the 33 JavaScript Concepts project. The goal is to maximize search visibility for JavaScript developers. runs entirely locally. Works wi….
- Inputs: target material, constraints, expected output, and acceptance criteria.
- Evidence boundary: follow “When to Use / Goal / SEO Audit Methodology” and do not present inference as author intent.

## PART B: Execution result
- **01** The card summarizes the use case; runtime output centers on “Perform a focused SEO audit on JavaScript concept pages to maximize search visibility, featured snippet optimization, and ranking potential Use this skill to perform a focused SEO audit on concept documentation pages for the 33 JavaScript Concepts project. The goal is to maximize search visibility for JavaScript developers. runs entirely locally. Works wi…”.
- **02** When the source has headings, the agent prioritizes “When to Use / Goal / SEO Audit Methodology” so the result follows the author’s structure.
- **03** Typical output includes task judgment, concrete steps, required commands or file edits, validation, and follow-up options.
- **04** Risk context follows the fingerprint: read files, write/modify files, run shell commands; mostly runs locally; usually needs no extra API key.

## Running Rules
- read files, write/modify files, run shell commands; mostly runs locally; usually needs no extra API key.
- Validate with a small sample before expanding scope.
- Return the result, validation criteria, and next iteration options.

SKILL.md SKILL.md

---
name: seo-review
description: Perform a focused SEO audit on JavaScript concept pages to maximize search visibility, featured…
category: security
source: leonardomso/33-js-concepts
---

# seo-review

## When to use
- Perform a focused SEO audit on JavaScript concept pages to maximize search visibility, featured snippet optimization…
- Use it when the task has clear inputs, repeatable steps, and validation criteria.

## What to provide
- Target material, scope, expected result, and forbidden changes.
- Whether network, commands, file writes, or external services are allowed.

## Execution rules
- Organize steps around “When to Use / Goal / SEO Audit Methodology” and keep inference separate from source facts.
- read files, write/modify files, run shell commands; mostly runs locally; usually needs no extra API key.
- Validate with a small sample before expanding the task.

## Output requirements
- Return the deliverable, key evidence, validation method, and next action.
- Mark missing information as unknown; do not invent commands, platforms, or dependencies.

Evidence boundary and execution chain

The author source anchors workflow facts; repository files anchor sources and commands; Fluxly only adds fit, limitations, and quality judgment.

skill "seo-review" {
  input      -> user goal + target files + boundaries + acceptance criteria
  context    -> When to Use / Goal / SEO Audit Methodology
  rules      -> SKILL.md triggers / order / output contract
  runtime    -> no special runtime | read files, write/modify files, run shell commands | mostly runs locally
  guardrails -> usually needs no extra API key + small-sample validation + diff/log review
  output     -> copyable result + checklist + next iteration
}

Interpretation is structured for decision-making; original keeps the upstream SKILL.md unchanged.

Decide Fit First

Core job: Perform a focused SEO audit on JavaScript concept pages to maximize search visibility, featured snippet optimization, and rankin…
Best fit: Use it when the task has reusable inputs, steps, and validation criteria rather than a one-off answer.
Avoid forcing it: If the source lacks commands, platform support, or external-service evidence, keep those fields unknown instead of guessing.

Design Intent

Structure: The skill is organized around “When to Use”, “Goal”, “SEO Audit Methodology”, “Step 1: Identify Target Keywords”, showing how the author expects the agent to judge fit, collect context, and produce verifiable output.
Trigger evidence: Prioritize the author’s wording around when to use it, what context to collect, and what output shape to produce.
Evidence boundary: Author text states facts, repository files prove commands and paths, and Fluxly only adds fit, limits, and usage judgment.

How To Use It

Inputs: Provide target material, scope, expected result, forbidden changes, and validation method.
Invocation: Name seo-review directly; if the source includes slash commands, start with the command and then add task context.
Validation: Start small and check whether the result follows “When to Use / Goal / SEO Audit Methodology” before expanding.

Boundaries And Review

Dependencies: It usually needs no extra API key, so start with a small validation task.
Permissions: Declared permissions include read / write / shell-exec; ask the agent to state file, command, and rollback boundaries before acting.
Quality bar: A useful result names the deliverable, evidence, and next action. Generic prose means the task needs tighter context.

Skill: SEO Audit for Concept Pages

Use this skill to perform a focused SEO audit on concept documentation pages for the 33 JavaScript Concepts project. The goal is to maximize search visibility for JavaScript developers.

When to Use

Before publishing a new concept page
When optimizing underperforming pages
Periodic content audits
After major content updates
When targeting new keywords

Goal

Each concept page should rank for searches like:

"what is [concept] in JavaScript"
"how does [concept] work in JavaScript"
"[concept] JavaScript explained"
"[concept] JavaScript tutorial"
"[concept] JavaScript example"

SEO Audit Methodology

Follow these five steps for a complete SEO audit.

Step 1: Identify Target Keywords

Before auditing, identify the keyword cluster for the concept.

Keyword Cluster Template

Type	Pattern	Example (Closures)
Primary	[concept] JavaScript	closures JavaScript
What is	what is [concept] in JavaScript	what is a closure in JavaScript
How does	how does [concept] work	how do closures work
How to	how to use/create [concept]	how to use closures
Why	why use [concept]	why use closures JavaScript
Examples	[concept] examples	closure examples JavaScript
vs	[concept] vs [related]	closures vs scope
Interview	[concept] interview questions	closure interview questions

Step 2: On-Page SEO Audit

Check all on-page SEO elements systematically.

Step 3: Featured Snippet Optimization

Verify content is structured to win featured snippets.

Step 4: Internal Linking Audit

Check the internal link structure.

Step 5: Generate Report

Document findings using the report template.

Keyword Clusters by Concept

Use these pre-built keyword clusters for each concept.

| Type | Keywords | |------|----------| | Primary | JavaScript call stack, call stack JavaScript | | What is | what is the call stack in JavaScript | | How does | how does the call stack work | | Error | maximum call stack size exceeded, stack overflow JavaScript | | Visual | call stack visualization, call stack explained | | Interview | call stack interview questions JavaScript | | Type | Keywords | |------|----------| | Primary | JavaScript primitive types, primitives in JavaScript | | What are | what are primitive types in JavaScript | | List | JavaScript data types, types in JavaScript | | vs | primitives vs objects JavaScript | | typeof | typeof JavaScript, JavaScript typeof operator | | Interview | JavaScript types interview questions | | Type | Keywords | |------|----------| | Primary | JavaScript value vs reference, pass by reference JavaScript | | What is | what is pass by value in JavaScript | | How does | how does JavaScript pass objects | | Comparison | value types vs reference types JavaScript | | Copy | how to copy objects JavaScript, deep copy JavaScript | | Type | Keywords | |------|----------| | Primary | JavaScript type coercion, type conversion JavaScript | | What is | what is type coercion in JavaScript | | How does | how does type coercion work | | Implicit | implicit type conversion JavaScript | | Explicit | explicit type conversion JavaScript | | Interview | type coercion interview questions | | Type | Keywords | |------|----------| | Primary | JavaScript equality, == vs === JavaScript | | What is | what is the difference between == and === | | Comparison | loose equality vs strict equality JavaScript | | Best practice | when to use == vs === | | Interview | JavaScript equality interview questions | | Type | Keywords | |------|----------| | Primary | JavaScript closures, JavaScript scope | | What is | what is a closure in JavaScript, what is scope | | How does | how do closures work, how does scope work | | Types | types of scope JavaScript, lexical scope | | Use cases | closure use cases, why use closures | | Interview | closure interview questions JavaScript | | Type | Keywords | |------|----------| | Primary | JavaScript event loop, event loop JavaScript | | What is | what is the event loop in JavaScript | | How does | how does the event loop work | | Visual | event loop visualization, event loop explained | | Related | call stack event loop, task queue JavaScript | | Interview | event loop interview questions | | Type | Keywords | |------|----------| | Primary | JavaScript Promises, Promises in JavaScript | | What is | what is a Promise in JavaScript | | How to | how to use Promises, how to chain Promises | | Methods | Promise.all, Promise.race, Promise.allSettled | | Error | Promise error handling, Promise catch | | vs | Promises vs callbacks, Promises vs async await | | Type | Keywords | |------|----------| | Primary | JavaScript async await, async await JavaScript | | What is | what is async await in JavaScript | | How to | how to use async await, async await tutorial | | Error | async await error handling, try catch async | | vs | async await vs Promises | | Interview | async await interview questions | | Type | Keywords | |------|----------| | Primary | JavaScript this keyword, this in JavaScript | | What is | what is this in JavaScript | | How does | how does this work in JavaScript | | Binding | call apply bind JavaScript, this binding | | Arrow | this in arrow functions | | Interview | this keyword interview questions | | Type | Keywords | |------|----------| | Primary | JavaScript prototype, prototype chain JavaScript | | What is | what is a prototype in JavaScript | | How does | how does prototype inheritance work | | Chain | prototype chain explained | | vs | prototype vs class JavaScript | | Interview | prototype interview questions JavaScript | | Type | Keywords | |------|----------| | Primary | JavaScript DOM, DOM manipulation JavaScript | | What is | what is the DOM in JavaScript | | How to | how to manipulate DOM JavaScript | | Methods | getElementById, querySelector JavaScript | | Events | DOM events JavaScript, event listeners | | Performance | DOM performance, virtual DOM vs DOM | | Type | Keywords | |------|----------| | Primary | JavaScript higher order functions, higher order functions | | What are | what are higher order functions | | Examples | map filter reduce JavaScript | | How to | how to use higher order functions | | Interview | higher order functions interview | | Type | Keywords | |------|----------| | Primary | JavaScript recursion, recursion in JavaScript | | What is | what is recursion in JavaScript | | How to | how to write recursive functions | | Examples | recursion examples JavaScript | | vs | recursion vs iteration JavaScript | | Interview | recursion interview questions |

Audit Checklists

Title Tag Checklist (4 points)

#	Check	Points	How to Verify
1	Length 50-60 characters	1	Count characters in `title` frontmatter
2	Primary keyword in first half	1	Concept name appears early
3	Ends with "in JavaScript"	1	Check title ending
4	Contains compelling hook	1	Promises value/benefit to reader

Scoring:

4/4: ✅ Excellent
3/4: ⚠️ Good, minor improvements possible
0-2/4: ❌ Needs significant work

Title Formula:

[Concept]: [What You'll Understand] in JavaScript

Good Examples:

Concept	Title (with character count)
Closures	"Closures: How Functions Remember Their Scope in JavaScript" (58 chars)
Event Loop	"Event Loop: How Async Code Actually Runs in JavaScript" (54 chars)
Promises	"Promises: Handling Async Operations in JavaScript" (49 chars)
DOM	"DOM: How Browsers Represent Web Pages in JavaScript" (51 chars)

Bad Examples:

Issue	Bad Title	Better Title
Too short	"Closures"	"Closures: How Functions Remember Their Scope in JavaScript"
Too long	"Understanding JavaScript Closures and How They Work with Examples" (66 chars)	"Closures: How Functions Remember Their Scope in JavaScript" (58 chars)
No hook	"JavaScript Closures"	"Closures: How Functions Remember Their Scope in JavaScript"
Missing "JavaScript"	"Understanding Closures and Scope"	Add "in JavaScript" at end

Meta Description Checklist (4 points)

#	Check	Points	How to Verify
1	Length 150-160 characters	1	Count characters in `description` frontmatter
2	Starts with action word	1	"Learn", "Understand", "Discover" (NOT "Master")
3	Contains primary keyword	1	Concept name + "JavaScript" present
4	Promises specific value	1	Lists what reader will learn

Description Formula:

[Action word] [what it is] in JavaScript. [Specific things they'll learn]: [topic 1], [topic 2], and [topic 3].

Good Examples:

Concept	Description
Closures	"Learn JavaScript closures and how functions remember their scope. Covers lexical scoping, practical use cases, memory considerations, and common closure patterns." (159 chars)
Event Loop	"Discover how the JavaScript event loop manages async code execution. Understand the call stack, task queue, microtasks, and why JavaScript is single-threaded but non-blocking." (176 chars - trim!)
DOM	"Learn how the DOM works in JavaScript. Understand how browsers represent HTML as a tree, select and manipulate elements, traverse nodes, and optimize rendering." (162 chars)

Bad Examples:

Issue	Bad Description	Fix
Too short	"Learn about closures"	Expand to 150-160 chars with specifics
Starts with "Master"	"Master JavaScript closures..."	"Learn JavaScript closures..."
Too vague	"A guide to closures"	List specific topics covered
Missing keyword	"Functions can remember things"	Include "closures" and "JavaScript"

Keyword Placement Checklist (5 points)

#	Check	Points	How to Verify
1	Primary keyword in title	1	Check frontmatter `title`
2	Primary keyword in meta description	1	Check frontmatter `description`
3	Primary keyword in first 100 words	1	Check opening paragraphs
4	Keyword in at least one H2 heading	1	Scan all `##` headings
5	No keyword stuffing	1	Content reads naturally

Keyword Placement Map:

┌─────────────────────────────────────────────────────────────────────────┐
│                         KEYWORD PLACEMENT                                │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  🔴 CRITICAL (Must have keyword)                                         │
│  ─────────────────────────────────                                       │
│  • title frontmatter                                                     │
│  • description frontmatter                                               │
│  • First paragraph (within 100 words)                                    │
│  • At least one H2 heading                                               │
│                                                                          │
│  🟡 RECOMMENDED (Include naturally)                                      │
│  ──────────────────────────────────                                      │
│  • "What you'll learn" Info box                                          │
│  • H3 subheadings                                                        │
│  • Key Takeaways section                                                 │
│  • First sentence after major H2s                                        │
│                                                                          │
│  ⚠️ AVOID                                                                │
│  ─────────                                                               │
│  • Same phrase >4 times per 1000 words                                   │
│  • Forcing keywords where pronouns work better                           │
│  • Awkward sentence structures to fit keywords                           │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Content Structure Checklist (6 points)

#	Check	Points	How to Verify
1	Opens with question hook	1	First paragraph asks engaging question
2	Code example in first 200 words	1	Simple example appears early
3	"What you'll learn" Info box	1	`<Info>` component after opening
4	Short paragraphs (2-4 sentences)	1	Scan content for long blocks
5	1,500+ words	1	Word count check
6	Key terms bolded on first mention	1	Important terms use `bold`

Content Structure Template:

┌─────────────────────────────────────────────────────────────────────────┐
│                       IDEAL PAGE STRUCTURE                               │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  1. QUESTION HOOK (First 50 words)                                       │
│     "How does JavaScript...? Why do...?"                                 │
│                                                                          │
│  2. BRIEF ANSWER + CODE EXAMPLE (Words 50-200)                           │
│     Quick explanation + simple code demo                                 │
│                                                                          │
│  3. "WHAT YOU'LL LEARN" INFO BOX                                         │
│     5-7 bullet points                                                    │
│                                                                          │
│  4. PREREQUISITES WARNING (if applicable)                                │
│     Link to required prior concepts                                      │
│                                                                          │
│  5. MAIN CONTENT SECTIONS (H2s)                                          │
│     Each H2 answers a question or teaches a concept                      │
│     Include code examples, diagrams, tables                              │
│                                                                          │
│  6. COMMON MISTAKES / GOTCHAS SECTION                                    │
│     What trips people up                                                 │
│                                                                          │
│  7. KEY TAKEAWAYS                                                        │
│     8-10 numbered points summarizing everything                          │
│                                                                          │
│  8. TEST YOUR KNOWLEDGE                                                  │
│     5-6 Q&A accordions                                                   │
│                                                                          │
│  9. RELATED CONCEPTS                                                     │
│     4 cards linking to related topics                                    │
│                                                                          │
│  10. RESOURCES (Reference, Articles, Videos)                             │
│      MDN links, curated articles, videos                                 │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Featured Snippet Checklist (4 points)

#	Check	Points	How to Verify
1	"What is X" has 40-60 word definition	1	Count words in first paragraph after "What is" H2
2	At least one H2 is phrased as question	1	Check for "What is", "How does", "Why" H2s
3	Numbered steps for "How to" content	1	Uses `<Steps>` component or numbered list
4	Comparison tables (if applicable)	1	Tables for "X vs Y" content

Featured Snippet Patterns:

┌─────────────────────────────────────────────────────────────────────────┐
│                     FEATURED SNIPPET FORMATS                             │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                          │
│  QUERY TYPE             WINNING FORMAT         YOUR CONTENT              │
│  ───────────            ──────────────         ────────────              │
│                                                                          │
│  "What is X"            Paragraph              40-60 word definition     │
│                                                after H2, bold keyword    │
│                                                                          │
│  "How to X"             Numbered list          <Steps> component or      │
│                                                1. 2. 3. markdown         │
│                                                                          │
│  "X vs Y"               Table                  | Feature | X | Y |       │
│                                                comparison table          │
│                                                                          │
│  "Types of X"           Bullet list            - **Type 1** — desc       │
│                                                - **Type 2** — desc       │
│                                                                          │
│  "[X] examples"         Code block             ```javascript             │
│                         + explanation          // example code           │
│                                                                          │
└─────────────────────────────────────────────────────────────────────────┘

Definition Paragraph Example (40-60 words):

## What is a Closure in JavaScript?

A **closure** is a function that retains access to variables from its outer 
(enclosing) scope, even after that outer function has finished executing. 
Closures are created every time a function is created in JavaScript, allowing 
inner functions to "remember" and access their lexical environment.

(This is 52 words - perfect for a featured snippet)

Internal Linking Checklist (4 points)

#	Check	Points	How to Verify
1	3-5 related concepts linked in body	1	Count `/concepts/` links in prose
2	Descriptive anchor text	1	No "click here", "here", "this"
3	Prerequisites in Warning box	1	`<Warning>` with links at start
4	Related Concepts section has 4 cards	1	`<CardGroup>` at end with 4 Cards

Good Anchor Text:

❌ Bad	✓ Good
"click here"	"event loop concept"
"here"	"JavaScript closures"
"this article"	"our Promises guide"
"read more"	"understanding the call stack"

Link Placement Strategy:

<!-- In Prerequisites (Warning box) -->
<Warning>
**Prerequisite:** This guide assumes you understand [Promises](/concepts/promises) 
and the [Event Loop](/concepts/event-loop). Read those first if needed.
</Warning>

<!-- In Body Content (natural context) -->
When the callback finishes, it's added to the task queue — managed by 
the [event loop](/concepts/event-loop).

<!-- In Related Concepts Section -->
<CardGroup cols={2}>
  <Card title="Promises" icon="handshake" href="/concepts/promises">
    async/await is built on top of Promises
  </Card>
</CardGroup>

Technical SEO Checklist (3 points)

#	Check	Points	How to Verify
1	Single H1 per page	1	Only one `#` heading (the title)
2	URL slug contains keyword	1	`/concepts/closures` not `/concepts/topic-1`
3	No orphan pages	1	Page is linked from at least one other page

H1 Rule:

Every page should have exactly ONE H1 (your main title). This is critical for SEO:

The H1 tells Google what the page is about
Multiple H1s confuse search engines about page hierarchy
All other headings should be H2 (##) and below
The H1 should contain your primary keyword

# Closures in JavaScript     ← This is your H1 (only one!)

## What is a Closure?        ← H2 for sections
### Lexical Scope            ← H3 for subsections
## How Closures Work         ← Another H2

URL/Slug Best Practices:

✅ Good	❌ Bad
`/concepts/closures`	`/concepts/c1`
`/concepts/event-loop`	`/concepts/topic-7`
`/concepts/type-coercion`	`/concepts/abc123`
`/concepts/async-await`	`/concepts/async_await`

Rules for slugs:

Include primary keyword — The concept name should be in the URL
Use hyphens, not underscores — event-loop not event_loop
Keep slugs short and readable — Under 50 characters
No UUIDs, database IDs, or random strings
Lowercase only — /concepts/Event-Loop should be /concepts/event-loop

Orphan Page Detection:

An orphan page has no internal links pointing to it from other pages. This hurts SEO because:

Google may not discover or crawl it frequently
It signals the page isn't important to your site structure
Users can't navigate to it naturally
Link equity doesn't flow to the page

How to check for orphan pages:

Search the codebase for links to this concept: grep -r "/concepts/[slug]" docs/
Verify it appears in at least one other concept's "Related Concepts" section
Check that pages listing it as a prerequisite link back appropriately
Ensure it's included in the navigation (docs.json)

Fixing orphan pages:

Add the concept to related pages' "Related Concepts" CardGroup
Link to it naturally in body content of related concepts
Ensure bidirectional linking (if A links to B, B should link back to A where relevant)

Scoring System

Total Points Available: 30

Category	Max Points
Title Tag	4
Meta Description	4
Keyword Placement	5
Content Structure	6
Featured Snippets	4
Internal Linking	4
Technical SEO	3
Total	30

Score Interpretation

Score	Percentage	Status	Action
27-30	90-100%	✅ Excellent	Ready to publish
23-26	75-89%	⚠️ Good	Minor optimizations needed
17-22	55-74%	⚠️ Fair	Several improvements needed
0-16	<55%	❌ Poor	Significant work required

Common SEO Issues and Fixes

Title Tag Issues

Issue	Current	Fix
Too short (<50 chars)	"Closures" (8)	"Closures: How Functions Remember Their Scope in JavaScript" (58)
Too long (>60 chars)	"Understanding JavaScript Closures and How They Work with Examples" (66)	"Closures: How Functions Remember Their Scope in JavaScript" (58)
Missing keyword	"Understanding Scope"	Add concept name: "Closures: Understanding Scope in JavaScript"
No hook	"JavaScript Closures"	Add benefit: "Closures: How Functions Remember Their Scope in JavaScript"
Missing "JavaScript"	"Closures Explained"	Add at end: "Closures Explained in JavaScript"

Meta Description Issues

Issue	Current	Fix
Too short (<120 chars)	"Learn about closures" (20)	Expand with specifics to 150-160 chars
Too long (>160 chars)	[Gets truncated]	Edit ruthlessly, keep key information
Starts with "Master"	"Master JavaScript closures..."	"Learn JavaScript closures..."
No keyword	"Functions that remember"	Include "closures" and "JavaScript"
Too vague	"A guide to closures"	List specific topics: "Covers X, Y, and Z"

Content Structure Issues

Issue	Fix
No question hook	Start with "How does...?" or "Why...?"
Code example too late	Move simple example to first 200 words
Missing Info box	Add `<Info>` with "What you'll learn"
Long paragraphs	Break into 2-4 sentence chunks
Under 1,500 words	Add more depth, examples, edge cases
No bolded terms	Bold key concepts on first mention

Featured Snippet Issues

Issue	Fix
No "What is" definition	Add 40-60 word definition paragraph
Definition too long	Tighten to 40-60 words
No question H2s	Add "What is X?" or "How does X work?" H2
Steps not numbered	Use `<Steps>` or numbered markdown
No comparison tables	Add table for "X vs Y" sections

Internal Linking Issues

Issue	Fix
No internal links	Add 3-5 links to related concepts
Bad anchor text	Replace "click here" with descriptive text
No prerequisites	Add `<Warning>` with prerequisite links
Empty Related Concepts	Add 4 Cards linking to related topics

Technical SEO Issues

Issue	Fix
Multiple H1 tags	Keep only one `#` heading (the title), use `##` for all sections
Slug missing keyword	Rename file to include concept name (e.g., `closures.mdx`)
Orphan page	Add links from related concept pages' body or Related Concepts section
Underscore in slug	Use hyphens: `event-loop.mdx` not `event_loop.mdx`
Uppercase in slug	Use lowercase only: `async-await.mdx` not `Async-Await.mdx`
Slug too long	Shorten to primary keyword: `closures.mdx` not `understanding-javascript-closures-and-scope.mdx`

SEO Audit Report Template

Use this template to document your findings.

# SEO Audit Report: [Concept Name]

**File:** `/docs/concepts/[slug].mdx`
**Date:** YYYY-MM-DD
**Auditor:** [Name/Claude]
**Overall Score:** XX/30 (XX%)
**Status:** ✅ Excellent | ⚠️ Needs Work | ❌ Poor

---

## Score Summary

| Category | Score | Status |
|----------|-------|--------|
| Title Tag | X/4 | ✅/⚠️/❌ |
| Meta Description | X/4 | ✅/⚠️/❌ |
| Keyword Placement | X/5 | ✅/⚠️/❌ |
| Content Structure | X/6 | ✅/⚠️/❌ |
| Featured Snippets | X/4 | ✅/⚠️/❌ |
| Internal Linking | X/4 | ✅/⚠️/❌ |
| Technical SEO | X/3 | ✅/⚠️/❌ |
| **Total** | **X/30** | **STATUS** |

---

## Target Keywords

**Primary Keyword:** [e.g., "JavaScript closures"]
**Secondary Keywords:**
- [keyword 1]
- [keyword 2]
- [keyword 3]

**Search Intent:** Informational / How-to / Comparison

---

## Title Tag Analysis

**Current Title:** "[current title from frontmatter]"
**Character Count:** XX characters
**Score:** X/4

| Check | Status | Notes |
|-------|--------|-------|
| Length 50-60 chars | ✅/❌ | XX characters |
| Primary keyword in first half | ✅/❌ | [notes] |
| Ends with "in JavaScript" | ✅/❌ | [notes] |
| Contains compelling hook | ✅/❌ | [notes] |

**Issues Found:** [if any]

**Recommended Title:** "[suggested title]" (XX chars)

---

## Meta Description Analysis

**Current Description:** "[current description from frontmatter]"
**Character Count:** XX characters
**Score:** X/4

| Check | Status | Notes |
|-------|--------|-------|
| Length 150-160 chars | ✅/❌ | XX characters |
| Starts with action word | ✅/❌ | Starts with "[word]" |
| Contains primary keyword | ✅/❌ | [notes] |
| Promises specific value | ✅/❌ | [notes] |

**Issues Found:** [if any]

**Recommended Description:** "[suggested description]" (XX chars)

---

## Keyword Placement Analysis

**Score:** X/5

| Location | Present | Notes |
|----------|---------|-------|
| Title | ✅/❌ | [notes] |
| Meta description | ✅/❌ | [notes] |
| First 100 words | ✅/❌ | Found at word XX |
| H2 heading | ✅/❌ | Found in: "[H2 text]" |
| Natural reading | ✅/❌ | [no stuffing / stuffing detected] |

**Missing Keyword Placements:**
- [ ] [Location where keyword should be added]

---

## Content Structure Analysis

**Word Count:** X,XXX words
**Score:** X/6

| Check | Status | Notes |
|-------|--------|-------|
| Question hook opening | ✅/❌ | [notes] |
| Code in first 200 words | ✅/❌ | Code appears at word XX |
| "What you'll learn" box | ✅/❌ | [present/missing] |
| Short paragraphs | ✅/❌ | [notes on paragraph length] |
| 1,500+ words | ✅/❌ | X,XXX words |
| Bolded key terms | ✅/❌ | [notes] |

**Structure Issues:**
- [ ] [Issue and recommendation]

---

## Featured Snippet Analysis

**Score:** X/4

| Check | Status | Notes |
|-------|--------|-------|
| 40-60 word definition | ✅/❌ | Currently XX words |
| Question-format H2 | ✅/❌ | Found: "[H2]" / Not found |
| Numbered steps | ✅/❌ | [notes] |
| Comparison tables | ✅/❌/N/A | [notes] |

**Snippet Opportunities:**

1. **"What is [concept]" snippet:**
   - Current definition: XX words
   - Action: [Expand to/Trim to] 40-60 words

2. **"How to [action]" snippet:**
   - Action: [Add Steps component / Already present]

---

## Internal Linking Analysis

**Score:** X/4

| Check | Status | Notes |
|-------|--------|-------|
| 3-5 internal links in body | ✅/❌ | Found X links |
| Descriptive anchor text | ✅/❌ | [notes] |
| Prerequisites in Warning | ✅/❌ | [present/missing] |
| Related Concepts section | ✅/❌ | X cards present |

**Current Internal Links:**
1. [Anchor text] → `/concepts/[slug]`
2. [Anchor text] → `/concepts/[slug]`

**Recommended Links to Add:**
- Link to [concept] in [section/context]
- Link to [concept] in [section/context]

**Bad Anchor Text Found:**
- Line XX: "click here" → change to "[descriptive text]"

---

## Technical SEO Analysis

**Score:** X/3

| Check | Status | Notes |
|-------|--------|-------|
| Single H1 per page | ✅/❌ | [Found X H1 tags] |
| URL slug contains keyword | ✅/❌ | Current: `/concepts/[slug]` |
| Not an orphan page | ✅/❌ | Linked from X other pages |

**H1 Tags Found:**
- Line XX: `# [H1 text]` ← Should be the only one
- [List any additional H1s that need to be changed to H2]

**Slug Analysis:**
- Current slug: `[slug].mdx`
- Contains keyword: ✅/❌
- Format correct: ✅/❌ (lowercase, hyphens, no special chars)

**Incoming Links Found:**
1. `/concepts/[other-concept]` → Links to this page in [section]
2. `/concepts/[other-concept]` → Links in Related Concepts

**If orphan page, add links from:**
- [Suggested concept page] in [section]
- [Suggested concept page] in Related Concepts

---

## Priority Fixes

### High Priority (Do First)

1. **[Issue]**
   - Current: [what it is now]
   - Recommended: [what it should be]
   - Impact: [why this matters]

2. **[Issue]**
   - Current: [what it is now]
   - Recommended: [what it should be]
   - Impact: [why this matters]

### Medium Priority

1. **[Issue]**
   - Recommendation: [fix]

### Low Priority (Nice to Have)

1. **[Issue]**
   - Recommendation: [fix]

---

## Competitive Analysis (Optional)

**Top-Ranking Pages for "[primary keyword]":**

1. **[Competitor 1 - URL]**
   - What they do well: [observation]
   - Word count: ~X,XXX

2. **[Competitor 2 - URL]**
   - What they do well: [observation]
   - Word count: ~X,XXX

**Our Advantages:**
- [What we do better]

**Gaps to Fill:**
- [What we're missing that competitors have]

---

## Implementation Checklist

After making fixes, verify:

- [ ] Title is 50-60 characters with keyword and hook
- [ ] Description is 150-160 characters with action word and value
- [ ] Primary keyword in title, description, first 100 words, and H2
- [ ] Opens with question hook
- [ ] Code example in first 200 words
- [ ] "What you'll learn" Info box present
- [ ] Paragraphs are 2-4 sentences
- [ ] 1,500+ words total
- [ ] Key terms bolded on first mention
- [ ] 40-60 word definition for featured snippet
- [ ] At least one question-format H2
- [ ] 3-5 internal links with descriptive anchor text
- [ ] Prerequisites in Warning box (if applicable)
- [ ] Related Concepts section has 4 cards
- [ ] Single H1 per page (title only)
- [ ] URL slug contains primary keyword
- [ ] Page linked from at least one other concept page
- [ ] All fixes implemented and verified

---

## Final Recommendation

**Ready to Publish:** ✅ Yes / ❌ No - [reason]

**Next Review Date:** [When to re-audit, e.g., "3 months" or "after major update"]

Quick Reference

Character Counts

Element	Ideal Length
Title	50-60 characters
Meta Description	150-160 characters
Definition paragraph	40-60 words

Keyword Density

Don't exceed 3-4 mentions of exact phrase per 1,000 words
Use variations naturally (e.g., "closures", "closure", "JavaScript closures")

Content Length

Length	Assessment
<1,000 words	Too thin - add depth
1,000-1,500	Minimum viable
1,500-2,500	Good
2,500-4,000	Excellent
>4,000	Consider splitting

Summary

When auditing a concept page for SEO:

Identify target keywords using the keyword cluster for that concept
Check title tag — 50-60 chars, keyword first, hook, ends with "JavaScript"
Check meta description — 150-160 chars, action word, keyword, specific value
Verify keyword placement — Title, description, first 100 words, H2
Audit content structure — Question hook, early code, Info box, short paragraphs
Optimize for featured snippets — 40-60 word definitions, numbered steps, tables
Check internal linking — 3-5 links, good anchors, Related Concepts section
Generate report — Document score, issues, and prioritized fixes

Remember: SEO isn't about gaming search engines — it's about making content easy to find for developers who need it. Every optimization should also improve the reader experience.

Install command

One-click installPick a runner, click Copy, paste into your terminal, press enter

npx skills add leonardomso/33-js-concepts/.claude/skills/seo-review -y

Open general install guide

View skill source

Works with

Claude Code
Cursor
Cline
Codex
Windsurf
Gemini
OpenCode
Roo Code
AAide
+Augment
GitHub Copilot
OpenClaw
KKiro
Junie
WWarp
Goose
Trae
Kilo Code
OpenHands
Amp
Zencoder
CContinue
AIAider
CodeBuddy
CodeGeeX
Replit Agent

Security audit

88 / 100

Community

未声明 license/许可。
未声明 version。
未限定 allowed-tools，默认拥有全部工具权限。

Metadata

Source: github
leonardomso/33-js-concepts
中文

More by @leonardomso

A concept-workflow 88

Category & tags

Category Security