Przejdź do treści
Biblioteka skilli
Marketing i treści · Budowanie i kod

seo-technical

/seo-technical

Projektuje tryb renderowania, adresy i przekierowania, tak by strony, które powinny się pojawiać w wyszukiwarce, były dostępne i szybkie.

Repozytorium
ai-skill-ai ↗
Licencja
MIT
Ostatnia zmiana repozytorium
31.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
6
Skrypty
1
Komentarze HTML
0
Adresy URL w SKILL.md
0
Przestarzałość

Brak sygnałów. Repozytorium zmienione 31.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 1 skrypt w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: scripts/seo_lint.py

Co robi i kiedy

Projektuje tryb renderowania, adresy i przekierowania, tak by strony, które powinny się pojawiać w wyszukiwarce, były dostępne i szybkie.

Oryginalny opis (EN)

Build a site so every page that should rank is crawlable, renderable, canonical and fast. Use when choosing a rendering mode per framework (Next.js App Router, Nuxt, SvelteKit, Astro, Remix or React Router, Angular), designing URLs and canonicals, handling pagination, faceted navigation or infinite scroll, setting hreflang, planning redirects or a migration, shaping internal link depth, gating many generated pages, or writing robots.txt and SEO headers. Measures built HTML with a script before claiming, and refuses dynamic rendering, which Google calls a deprecated workaround. Triggers on SEO

Jak działa

  1. When to use and when to stay off
  2. Non-negotiables
  3. Procedure
  4. Self-audit
  5. What this cannot do
Sekcje z nagłówków SKILL.md, w oryginale · 180 linii, 1 974 słów
Podgląd SKILL.md
---
name: seo-technical
description: Build a site so every page that should rank is crawlable, renderable, canonical and fast. Use when choosing a rendering mode per framework (Next.js App Router, Nuxt, SvelteKit, Astro, Remix or React Router, Angular), designing URLs and canonicals, handling pagination, faceted navigation or infinite scroll, setting hreflang, planning redirects or a migration, shaping internal link depth, gating many generated pages, or writing robots.txt and SEO headers. Measures built HTML with a script before claiming, and refuses dynamic rendering, which Google calls a deprecated workaround. Triggers on SEO build, crawlable, renderable, canonical tag, pagination SEO, faceted navigation, hreflang, redirect map, site migration, internal linking, robots.txt, programmatic SEO, noindex a page type, rendering strategy for SEO. For an existing-site audit use seo-audit. For indexing report triage use seo-indexing. For keywords and copy use seo-content. For JSON-LD use structured-data. For AI crawler access use ai-search-visibility.
license: MIT
metadata:
  version: 1.0.0
  suite: ai-skill
---

# Technical SEO build

The common failure is shipping pages that read well in a browser and are invisible to a crawler: a
route that renders its body only after a client fetch, a canonical that points a whole page type at
one URL, a filter that spawns a million parameter URLs, a migration that drops its redirect map. None
of these show up in design review, because the browser hides them. They show up weeks later as a
traffic drop nobody can explain. This skill builds the crawl, render, canonical and speed story into
the site from the first commit, and measures the built output instead of trusting the source.

## When to use and when to stay off

Run when the task decides whether a URL can be crawled, rendered or indexed at build time: picking a
rendering mode, designing URL and canonical rules, pagination and faceted navigation, hreflang,
redirects and migrations, internal link architecture, gating generated pages, robots.txt, or SEO
headers. Run it before a release that adds a new page type or a new route shape.

Stay off, and route instead, when:

- The site already exists and the question is which pages are broken. Use `seo-audit` for the full crawl and issue catalogue.
- The symptom is a Search Console indexing report or pages missing from Google after launch. Use `seo-indexing`.
- The work is keywords, search intent, briefs or on-page copy. Use `seo-content`.
- The work is JSON-LD or rich result eligibility. Use `structured-data`.
- The question is AI crawler access, llms.txt or being cited by AI answers. Use `ai-search-visibility`.
- Pages are crawlable and the problem is load speed. Use `performance-tuning`.
- The work is the deploy pipeline or hosting itself. Use `infra-deploy`.

The user says "stop", "I've decided", or "just execute": comply at once and stay off for the rest of
the session unless asked again.

## Non-negotiables

These override everything else in this file.

1. Measure the built output, not the source. Status code, rendered HTML, canonical, robots directives and hreflang come from a live fetch or from `scripts/seo_lint.py` against the build, never from reading the component alone. A framework config can lie about what ships.
2. No dynamic rendering, no user-agent branching for content. Google states dynamic rendering was a workaround, not a long-term solution, and tells sites to use server-side rendering, static rendering or hydration instead (Search Central, verified October 2026). Serving crawlers different HTML than users risks cloaking.
3. One index-policy function is the single source of truth. Whether a URL is indexable is decided in one place that the route, the `<meta robots>` output, the sitemap and the internal links all call. A sitemap must never list a URL the route sets to noindex.
4. A page that should rank returns 200 with its main content in the initial HTML. A page that is gone returns 404 or 410, a moved page returns 301, and a route that renders an empty shell for a missing record is a soft 404 and gets fixed.
5. Never block a noindex page in robots.txt. A URL blocked from crawling cannot have its noindex read, so it can stay indexed with no snippet.
6. Every claim about a rendered page carries the fetch result and its date, or an `ASSUMPTION:` label with its risk. Framework behaviour and platform rules change between versions.

## Procedure

Framework-by-framework rendering recipes are in `references/framework-recipes.md`. Redirect-map and
migration mechanics are in `references/migrations.md`. Pagination and faceted-navigation decisions are
in `references/faceted-and-pagination.md`. Hreflang forms and the return-tag rule are in
`references/hreflang.md`.

### Step 1, decide the rendering mode per route

Group routes by how their content is produced, then pick the cheapest mode that puts the main content
in the initial HTML.

- Static content known at build time (marketing pages, docs, published articles): prerender to static HTML. Fastest to serve, nothing to render per request.
- Content that changes but not per visitor (product pages, listings, city pages): server-render or prerender with revalidation, so a crawler gets the full body on the first request.
- Content that is per visitor or behind auth: it does not need to rank, so client rendering is fine. Keep it out of the sitemap and out of the index.

Read `references/framework-recipes.md` for the exact mode names and gotchas per framework: Next.js App
Router (server components, `generateStaticParams`, revalidation), Nuxt, SvelteKit, Astro, Remix or
React Router, and Angular. For a route that must rank, confirm the mode by fetching the built page and
checking the body text is in the raw HTML, not injected by a later script.

### Step 2, design URLs and canonicals

URL rules: lowercase, hyphen-separated words, no session IDs or tracking parameters in the canonical
path, a stable slug that does not change when the title is edited, and no two URLs serving the same
content. Keep the meaningful part of the URL short and readable.

Canonical rules: every indexable page has a self-referential canonical with an absolute URL. A set of
duplicate or near-duplicate URLs points its canonical at the one version meant to rank. A canonical is
a strong hint, not an order, so it must agree with the sitemap, the internal links and any redirect:
contradicting signals get Google to pick its own canonical. Do not canonicalise a paginated set to
page one (see step 4).

### Step 3, set robots directives and headers

Decide per route whether it is indexable, and emit that from the one index-policy function in
non-negotiable 3. Use `<meta name="robots">` for HTML pages and the `X-Robots-Tag` header for
non-HTML files such as PDFs. Keep `robots.txt` for crawl control only (blocking admin, cart, internal
search), never as an indexing control, and never block a page you also noindex.

Useful headers: a correct `Content-Type`, `Cache-Control` tuned so a crawler is not served stale or
rebuilt-on-demand pages under load, and `Vary` where content negotiation happens. For snippet control
use `max-snippet`, `nosnippet` and `data-nosnippet` rather than hiding content.

### Step 4, handle pagination, faceting and infinite scroll

Pagination: Google does not use `rel="next"` and `rel="prev"` (confirmed; Google retired support
years ago). Each page in a sequence is its own indexable URL with a self canonical. Do not canonicalise
pages 2..N to page one, which hides their links and items. Give every paginated page a crawlable
`<a href>` link to the next page.

Faceted navigation: Google states faceted navigation is the most common source of overcrawling that
site owners report (Search Central, Crawling December 2024). Decide per facet, not with one blanket
rule: index the few high-demand filter pages that have real search demand and unique content, keep the
rest out with noindex or by not generating crawlable links to low-value combinations, and keep
`robots.txt` disallow for truly infinite parameter spaces. Read `references/faceted-and-pagination.md`
for the per-facet decision table.

Infinite scroll: a scroll feed that loads more items with JavaScript is not crawlable on its own. Back
it with real paginated URLs (`?page=2` or `/page/2`) that return the items in HTML, and link them so a
crawler can walk the set.

### Step 5, internal link architecture and depth

Every page that should rank is reachable by crawlable `<a href>` links. Google extracts URLs only from
`<a>` elements with an `href`; a link built from a script event or a button with an onclick is not
followed (Search Central, links best practices). Keep important pages within a few clicks of the home
page or a hub page. Use descriptive anchor text, not "click here". A page with no internal links
pointing at it is an orphan, found only in the sitemap if at all, and ranks poorly.

### Step 6, hreflang for multi-language or multi-region sites

Each localised URL lists every version of the page, including itself, with a correct
`hreflang` language or language-region code, plus an `x-default` for the fallback. The rule is
reciprocal: if page A points to page B, page B must point back to A, or Google ignores the set. Put
hreflang in one place only, chosen from HTML `<link>` tags, HTTP headers, or the sitemap form, never
mixed. Read `references/hreflang.md` for the code format and the sitemap example.

### Step 7, redirects and migrations

For a URL change or a platform move, build a redirect map before switching: every old URL to its
closest live equivalent, one hop, 301 for a permanent move. No chains, no loops, no redirect to a page
that then redirects again, and no mass redirect of everything to the home page, which Google treats as
a soft 404. Keep the map in version control. Read `references/migrations.md` for the move checklist,
the one-change-at-a-time rule, and what to watch in Search Console afterwards.

### Step 8, gate pages that come in large numbers

Before generating many similar pages (cities, products, tags, schemes):

1. Write down what each page has that no sibling and no hub page has. If the only difference is a place name or a number, keep those pages out of the index.
2. Put the index rule in the one function from non-negotiable 3, so the sitemap can never list a noindex page.
3. Open a batch of 10 to 20, record the date, and read the indexing report after about four weeks before opening more.

Google's spam policies treat pages made mainly to rank, with little value to users, as scaled content
abuse. Mass-generated thin pages are a liability, not reach.

### Step 9, verify the build

Run the linter against the built output before calling the work done:

```
python3 scripts/seo_lint.py ./dist --json report.json
```

It checks title, meta description, a single canonical, robots directives, hreflang reciprocity, exactly
one H1, Open Graph tags, JSON-LD presence, and duplicate titles across pages, with severities. Fix
high-severity findings, record the run and its date, and fetch a sample of live pages to confirm the
body text is in the raw HTML.

## Self-audit

- Every "renders for crawlers" claim quotes a fetch or a `seo_lint.py` run against the built output, with its date.
- No route uses dynamic rendering or user-agent branching for content.
- Indexability is decided in one function that the route, the meta output, the sitemap and the internal links all call.
- Pages that should rank return 200 with main content in the initial HTML; gone pages return 404 or 410; moved pages return a single 301.
- No paginated page is canonicalised to page one, and no `rel=next`/`rel=prev` is relied on for Google.
- Faceted URLs are decided per facet, not blanket-blocked and not left to multiply unchecked.
- Every indexable page has a self canonical with an absolute URL, agreeing with the sitemap and internal links.
- hreflang sets are reciprocal, carry `x-default`, and live in one location only.
- The redirect map has no chains or loops and no mass redirect to the home page.
- No noindex page is blocked in robots.txt.
- Generated page types state what each page has beyond a name or number, or they are kept out of the index.

## What this cannot do

It cannot see how Google renders a page; it can only confirm what the server ships. The URL Inspection
tool's rendered-HTML view is the closest signal and the user has to run it.

It cannot measure crawl behaviour without server logs. For crawler hit patterns, status-code mix and
crawl of non-canonical URLs, use the log parser in `seo-indexing` (`seo-indexing/scripts/log_audit.py`).

It cannot promise indexing or ranking. Removing crawl and render obstacles is in scope; inclusion is
Google's decision, and this skill never claims guaranteed indexing.

It cannot decide whether content a page publishes is legal. For a site in a regulated field (finance,
health, legal), ask a lawyer qualified in that field and country: "Does the content on these page types
need a licence, a disclaimer, or a named qualified author to be published lawfully here?"
Pliki w paczce (6)
  • SKILL.md 13 KB
  • references/faceted-and-pagination.md 3 KB
  • references/framework-recipes.md 4 KB
  • references/hreflang.md 3 KB
  • references/migrations.md 3 KB
  • scripts/seo_lint.py 16 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · devpilotX/ai-skill-ai100MIT
Thibaultbm/claude-seo-geo100MIT
AgriciDaniel/claude-seo100MIT
danieldannhofer-gif/vibe-seo-plugin100MIT
rampstackco/claude-skills100MIT
akn-official/agent-workspace-kit100MIT
tlynx538/OpenCode-Programming-Workflow100MIT
zhtyyx/codex-seo100MIT
Maudeunfledged834/startup-founder-skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki f71dfa9d8721 (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 90technical
    Przegląda kod projektu pod kątem technicznego SEO: robots.txt, mapy witryny, kanoniczne adresy, przekierowania i Core Web Vitals, z poprawkami w kodzie.
  • 90technical-seo
    Sprawdza i poprawia techniczne SEO aplikacji webowej: metadane, JSON-LD, mapę witryny, robots.txt, kanoniczne adresy i Core Web Vitals.
  • 100technical-seo-audit
    Przeprowadza ustrukturyzowany audyt techniczny SEO strony: dostęp robotów, indeksowalność, przekierowania, mapy witryny i dane strukturalne, z listą ustaleń.
  • 90seo-technical-audit
    Audytuje techniczne SEO: indeksację, robots i sitemapy, kanoniczne adresy, przekierowania, Core Web Vitals i renderowanie JS, z przypisanymi właścicielami.
  • 100ecommerce-seo
    Pomaga w SEO sklepów internetowych: dane strukturalne Product, nawigacja fasetowa, paginacja, produkty niedostępne i kanoniczne adresy wariantów.
  • 90fe-seo-metadata
    Pisze i przegląda tytuły, opisy, adresy kanoniczne, sitemapy i dane JSON-LD, by strony były znajdowane i dobrze udostępniane.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.