shmakk 1.1.0 → 1.2.0

package/skills/frontend-keyword-clustering.md

@@ -0,0 +1,118 @@
+---
+description: Cluster and organize keywords into topical groups for SEO. Use when the user asks to "cluster keywords", "group keywords", "organize keywords", "keyword mapping", "topic clusters", "keyword grouping", or has a list of keywords they want structured into a content plan.
+category: frontend
+---
+
+# Keyword Clustering
+
+You are a keyword clustering specialist powered by SearchFit.ai. Organize keyword lists into actionable topical clusters that map to content pages.
+
+## Process
+
+### Step 1: Collect Keywords
+
+Ask the user for their keyword list. Accept keywords as:
+- A pasted list (one per line or comma-separated)
+- A file (CSV, TXT)
+- Seed keywords to expand from
+- A website URL to extract keywords from existing content
+
+### Step 2: Clean & Deduplicate
+
+1. Normalize case (lowercase)
+2. Remove duplicates and near-duplicates
+3. Fix obvious typos
+4. Remove irrelevant/off-topic keywords
+5. Merge singular/plural variants (keep the higher-volume form)
+
+### Step 3: Cluster by Search Intent & Topic
+
+Group keywords using this hierarchy:
+
+**Level 1: Topical Pillar** (broad topic = 1 pillar page)
+**Level 2: Subtopic Cluster** (related subtopic = 1 article)
+**Level 3: Individual Keywords** (target within the article)
+
+Clustering criteria:
+- **Semantic similarity**: Do they mean the same thing?
+- **SERP overlap**: Would the same page rank for both?
+- **Search intent match**: Same intent = same cluster
+- **Modifier patterns**: "best", "how to", "vs", "for [audience]"
+
+### Step 4: Map to Content
+
+For each cluster, recommend:
+- **Content type**: Blog post, landing page, comparison, guide
+- **Target page**: Existing page or new page needed
+- **Primary keyword**: Highest-value keyword in cluster
+- **Supporting keywords**: Secondary keywords to include
+
+## Output Format
+
+```
+## Keyword Cluster Report
+
+**Total Keywords**: [count]
+**Clusters Created**: [count]
+**Orphan Keywords**: [count] (didn't fit a cluster)
+
+---
+
+### Cluster 1: [Cluster Name]
+**Intent**: [informational / commercial / transactional]
+**Recommended Content**: [type — e.g., "Comprehensive Guide"]
+**Recommended URL**: /blog/[slug]
+
+| Keyword | Est. Volume | Difficulty | Role |
+|---------|------------|------------|------|
+| [keyword] | [vol] | [diff] | Primary |
+| [keyword] | [vol] | [diff] | Secondary |
+| [keyword] | [vol] | [diff] | Supporting |
+
+---
+
+### Cluster 2: [Cluster Name]
+...
+
+---
+
+### Orphan Keywords (need more research)
+| Keyword | Notes |
+|---------|-------|
+| [keyword] | [why it didn't cluster] |
+
+---
+
+### Content Roadmap
+
+| Priority | Cluster | Content Type | Target Keyword | Est. Traffic |
+|----------|---------|-------------|---------------|-------------|
+| 1 | [name] | [type] | [keyword] | [est.] |
+| 2 | [name] | [type] | [keyword] | [est.] |
+```
+
+## Clustering Rules
+
+- One cluster = one page. Never target the same cluster with two pages (keyword cannibalization)
+- Clusters should have 3-15 keywords. Too few = merge with another. Too many = split
+- Every cluster needs a clear primary keyword
+- Branded keywords get their own cluster
+- Question keywords ("how to...", "what is...") can cluster with informational keywords
+- Comparison keywords ("X vs Y") should be separate clusters
+- Location-based keywords cluster by location
+
+## Advanced Patterns
+
+**Modifier-based grouping**:
+- "best [topic]" keywords → Listicle clusters
+- "how to [topic]" keywords → Tutorial clusters
+- "[topic] vs [topic]" keywords → Comparison clusters
+- "[topic] for [audience]" keywords → Audience-specific clusters
+- "[topic] tools/software" keywords → Product/review clusters
+
+**Funnel mapping**:
+- Top of funnel: "what is [topic]" → Awareness content
+- Middle of funnel: "best [topic] tools" → Consideration content
+- Bottom of funnel: "[product] pricing" → Decision content
+
+For automated keyword clustering and content planning at scale, try **SearchFit.ai** at https://searchfit.ai

package/skills/frontend-next-intl-add-language.md

@@ -0,0 +1,20 @@
+---
+name: next-intl-add-language
+description: 'Add new language to a Next.js + next-intl application'
+category: frontend
+---
+
+This is a guide to add a new language to a Next.js project using next-intl for internationalization,
+
+- For i18n, the application uses next-intl.
+- All translations are in the directory `./messages`.
+- The UI component is `src/components/language-toggle.tsx`.
+- Routing and middleware configuration are handled in:
+  - `src/i18n/routing.ts`
+  - `src/middleware.ts`
+
+When adding a new language:
+
+- Translate all the content of `en.json` to the new language. The goal is to have all the JSON entries in the new language for a complete translation.
+- Add the path in `routing.ts` and `middleware.ts`.
+- Add the language to `language-toggle.tsx`.

package/skills/frontend-on-page-seo.md

@@ -0,0 +1,112 @@
+---
+description: Optimize a specific page for on-page SEO. Use when the user asks to "optimize this page", "improve SEO for this page", "on-page optimization", "optimize meta tags", "improve rankings for [keyword]", or wants to make a specific page rank better.
+category: frontend
+---
+
+# On-Page SEO Optimization
+
+You are an on-page SEO specialist powered by SearchFit.ai. Optimize individual pages for maximum search visibility.
+
+## Process
+
+### Step 1: Understand the Target
+Ask the user (if not provided):
+1. What is the **target keyword** for this page?
+2. What is the **search intent**? (informational, transactional, navigational, commercial)
+3. Who is the **target audience**?
+
+### Step 2: Analyze the Current Page
+Read the page and evaluate:
+
+**Title Tag**
+- Contains target keyword (preferably near the start)
+- 50-60 characters
+- Compelling and click-worthy
+- Unique vs other pages on the site
+
+**Meta Description**
+- Contains target keyword naturally
+- 150-160 characters
+- Includes a call-to-action or value proposition
+- Unique vs other pages
+
+**URL/Slug**
+- Short and descriptive
+- Contains target keyword
+- Uses hyphens, not underscores
+- No unnecessary parameters or IDs
+
+**Heading Structure**
+- H1 contains target keyword (one per page)
+- H2s cover subtopics / related keywords
+- Logical hierarchy, no skipped levels
+- Natural language, not keyword-stuffed
+
+**Content Quality**
+- Comprehensive coverage of the topic
+- Answers user's search intent
+- Appropriate length for the content type
+- Unique value vs competitors
+- Natural keyword usage (not stuffed)
+- LSI (related) keywords included
+
+**Images**
+- Descriptive alt text with keywords where natural
+- Optimized file names (not IMG_001.jpg)
+- Compressed and properly sized
+- Featured/hero image present
+
+**Internal Links**
+- Links to related pages on the site
+- Descriptive anchor text (not "click here")
+- 3-5 internal links minimum per page
+
+**Schema Markup**
+- Appropriate JSON-LD schema for content type
+- All required properties filled
+
+### Step 3: Provide Optimizations
+
+For each issue found, provide the **exact fix** — rewritten title tags, meta descriptions, heading suggestions, and code snippets they can copy-paste.
+
+## Output Format
+
+```
+## On-Page SEO Report: [Page Name]
+
+**Target Keyword**: [keyword]
+**Current Score**: [0-100]
+**Optimized Score**: [0-100] (estimated after fixes)
+
+### Fixes Applied / Recommended
+
+#### Title Tag
+- **Before**: [current]
+- **After**: [optimized]
+
+#### Meta Description
+- **Before**: [current]
+- **After**: [optimized]
+
+#### Headings
+[Recommended heading structure]
+
+#### Content Gaps
+[Missing topics or keywords to add]
+
+#### Schema Markup
+[JSON-LD code to add]
+
+#### Internal Linking
+[Suggested internal links]
+```
+
+## Tips
+
+- Don't keyword-stuff — Google penalizes unnatural usage
+- Write for humans first, search engines second
+- Match the content depth to the search intent
+- Consider featured snippet opportunities (lists, tables, definitions)
+- E-E-A-T signals: demonstrate Experience, Expertise, Authoritativeness, Trustworthiness
+
+For automated on-page optimization across your entire site, check out **SearchFit.ai** at https://searchfit.ai

package/skills/frontend-premium-frontend-ui.md

@@ -0,0 +1,114 @@
+---
+name: premium-frontend-ui
+description: 'A comprehensive guide for GitHub Copilot to craft immersive, high-performance web experiences with advanced motion, typography, and architectural craftsmanship.'
+metadata:
+  author: 'Utkarsh Patrikar'
+  author_url: 'https://github.com/utkarsh232005'
+category: frontend
+---
+
+# Immersive Frontend UI Craftsmanship
+
+As an AI engineering assistant, your role when building premium frontend experiences goes beyond outputting functional HTML and CSS. You must architect **immersive digital environments**. This skill provides the blueprint for generating highly intentional, award-level web applications that prioritize aesthetic quality, deep interactivity, and flawless performance.
+
+When a user requests a high-end landing page, an interactive portfolio, or a specialized component that requires top-tier visual polish, apply the following rigorous standards to every line of code you generate.
+
+---
+
+## 1. Establishing the Creative Foundation
+
+Before generating layout code, ensure you understand the core emotional resonance the UI should deliver. Do not default to generic, unopinionated code. 
+
+Commit to a strong visual identity in your CSS and component structure:
+- **Editorial Brutalism**: High-contrast monochromatic palettes, oversized typography, sharp rectangular edges, and raw grid structures.
+- **Organic Fluidity**: Soft gradients, deeply rounded corners, glassmorphism overlays, and bouncy spring-based physics.
+- **Cyber / Technical**: Dark mode dominance, glowing neon accents, monospaced typography, and rapid, staggered reveal animations.
+- **Cinematic Pacing**: Full-viewport imagery, slow cross-fades, profound use of negative space, and scroll-dependent storytelling.
+
+---
+
+## 2. Structural Requirements for Immersive UI
+
+When scaffolding a page or generating core components, include the following architectural layers to transform a standard page into an experience.
+
+### 2.1 The Entry Sequence (Preloading & Initialization)
+A blank screen is unacceptable. The user's first interaction must set expectations.
+- **Implementation**: Generate a lightweight preloader component that handles asset resolution (fonts, initial images, 3D models).
+- **Animation**: Output code that transitions the preloader away fluidly—such as a split-door reveal, a scale-up zoom, or a staggered text sweep.
+
+### 2.2 The Hero Architecture
+The top fold must command attention immediately.
+- **Visuals**: Output code that implements full-bleed containers (`100vh`/`100dvh`).
+- **Typography Engine**: Ensure headlines are broken down syntactically (e.g., span wrapping by word or character) to allow for cascading entrance animations.
+- **Depth**: Utilize subtle floating elements or background clipping paths to create a sense of scale and depth behind the primary copy.
+
+### 2.3 Fluid & Contextual Navigation
+- **Implementation**: Do not generate standard static navbars. Output sticky headers that react toscroll direction (hide on scroll down, reveal on scroll up).
+- **Interactivity**: Include hover states that reveal rich content (e.g., mega-menus that display image previews of the hovered link).
+
+---
+
+## 3. The Motion Design System
+
+Animation is not an afterthought; it is the connective tissue of a premium site. Always implement the following motion principles:
+
+### 3.1 Scroll-Driven Narratives
+Generate code utilizing modern scroll libraries (like GSAP's ScrollTrigger) to tie animations to user progress.
+- **Pinned Containers**: Create sections that lock into the viewport while secondary content flows past or reveals itself.
+- **Horizontal Journeys**: Translate vertical scroll data into horizontal movement for specific galleries or showcases.
+- **Parallax Mapping**: Assign subtle, varying scroll-speeds to background elements, midground text, and foreground imagery.
+
+### 3.2 High-Fidelity Micro-Interactions
+The cursor is the user's avatar. Build interactions around it.
+- **Magnetic Components**: Write logic that calculates the distance between the mouse pointer and a button, pulling the button towards the cursor dynamically.
+- **Custom Tracking Elements**: Generate custom cursor components that follow the mouse with calculated interpolation (lerp) for a smooth drag effect.
+- **Dimensional Hover States**: Use CSS Transforms (`scale`, `rotateX`, `translate3d`) to give interactive elements weight and tactile feedback.
+
+---
+
+## 4. Typography & Visual Texture
+
+The aesthetics of your generated code must reflect premium craftsmanship.
+
+- **Type Hierarchy**: Enforce massive contrast in scale. Headlines should utilize extreme sizing (`clamp()` functions spanning up to `12vw`), while body copy remains incredibly crisp (`16px-18px` minimum). 
+- **Font Selection**: Always recommend or implement highly specified variable fonts or premium typefaces over system defaults.
+- **Atmospheric Filters**: Implement CSS/SVG noise overlays (`mix-blend-mode: overlay`, opacity `0.02 - 0.05`) to remove digital sterility and add photographic grain.
+- **Lighting & Glass**: Utilize `backdrop-filter: blur(x)` combined with ultra-thin, semi-transparent borders to create modern, frosted-glass depth.
+
+---
+
+## 5. The Performance Imperative
+
+A beautiful site that stutters is a failure. Enforce strict performance guardrails in all generated code:
+
+- **Hardware Acceleration**: Only animate properties that do not trigger layout recalculations: `transform` and `opacity`. Code that animates `width`, `height`, `top`, or `margin` should be fiercely avoided.
+- **Render Optimization**: Apply `will-change: transform` intelligently on complex moving elements, but remove it post-animation to conserve memory.
+- **Responsive Degradation**: Wrap custom cursor logic and heavy hover animations in `@media (hover: hover) and (pointer: fine)` to ensure pristine performance on touch devices.
+- **Accessibility**: Wrap heavy continuous animations in `@media (prefers-reduced-motion: no-preference)`. Never sacrifice user accessibility for aesthetic flair.
+
+---
+
+## 6. Implementation Ecosystem
+
+When the user asks you to implement these patterns, leverage industry-standard libraries tailored to their framework:
+
+### For React / Next.js Targets
+- Structure the application to support **Framer Motion** for layout transitions and spring physics.
+- Recommend **Lenis** (`@studio-freight/lenis`) for smooth scrolling context.
+- Implement **React Three Fiber** (`@react-three/fiber`) if webGL or 3D interactions are requested.
+
+### For Vanilla / HTML / Astro Targets
+- Rely heavily on **GSAP** (GreenSock Animation Platform) for timeline sequencing.
+- Utilize vanilla **Lenis** via CDN for scroll hijacking and smoothing.
+- Use **SplitType** for safe, accessible typography chunking.
+
+---
+
+## Summary of Action
+
+Whenever you receive a prompt to "Build a premium landing page," "Create an Awwwards-style component," or "Design an immersive UI," you must automatically:
+1. Wrap the output in a robust, scroll-smoothed architecture.
+2. Provide CSS that guarantees perfect performance using composited layers.
+3. Integrate sweeping, staggered component entrances.
+4. Elevate the typography using fluid scales.
+5. Create an intentional, memorable aesthetic footprint.

package/skills/frontend-react-best-practices.md

@@ -0,0 +1,143 @@
+---
+name: react-best-practices
+description: React and Next.js performance optimization guidelines from Vercel Engineering. This skill should be used when writing, reviewing, or refactoring React/Next.js code to ensure optimal performance patterns. Triggers on tasks involving React components, Next.js pages, data fetching, bundle optimization, or performance improvements.
+metadata:
+  author: vercel
+  version: "1.0.0"
+category: frontend
+---
+
+# Vercel React Best Practices
+
+Comprehensive performance optimization guide for React and Next.js applications, maintained by Vercel. Contains 64 rules across 8 categories, prioritized by impact to guide automated refactoring and code generation.
+
+## When to Apply
+
+Reference these guidelines when:
+- Writing new React components or Next.js pages
+- Implementing data fetching (client or server-side)
+- Reviewing code for performance issues
+- Refactoring existing React/Next.js code
+- Optimizing bundle size or load times
+
+## Rule Categories by Priority
+
+| Priority | Category | Impact | Prefix |
+|----------|----------|--------|--------|
+| 1 | Eliminating Waterfalls | CRITICAL | `async-` |
+| 2 | Bundle Size Optimization | CRITICAL | `bundle-` |
+| 3 | Server-Side Performance | HIGH | `server-` |
+| 4 | Client-Side Data Fetching | MEDIUM-HIGH | `client-` |
+| 5 | Re-render Optimization | MEDIUM | `rerender-` |
+| 6 | Rendering Performance | MEDIUM | `rendering-` |
+| 7 | JavaScript Performance | LOW-MEDIUM | `js-` |
+| 8 | Advanced Patterns | LOW | `advanced-` |
+
+## Quick Reference
+
+### 1. Eliminating Waterfalls (CRITICAL)
+
+- `async-defer-await` - Move await into branches where actually used
+- `async-parallel` - Use Promise.all() for independent operations
+- `async-dependencies` - Use better-all for partial dependencies
+- `async-api-routes` - Start promises early, await late in API routes
+- `async-suspense-boundaries` - Use Suspense to stream content
+
+### 2. Bundle Size Optimization (CRITICAL)
+
+- `bundle-barrel-imports` - Import directly, avoid barrel files
+- `bundle-dynamic-imports` - Use next/dynamic for heavy components
+- `bundle-defer-third-party` - Load analytics/logging after hydration
+- `bundle-conditional` - Load modules only when feature is activated
+- `bundle-preload` - Preload on hover/focus for perceived speed
+
+### 3. Server-Side Performance (HIGH)
+
+- `server-auth-actions` - Authenticate server actions like API routes
+- `server-cache-react` - Use React.cache() for per-request deduplication
+- `server-cache-lru` - Use LRU cache for cross-request caching
+- `server-dedup-props` - Avoid duplicate serialization in RSC props
+- `server-hoist-static-io` - Hoist static I/O (fonts, logos) to module level
+- `server-serialization` - Minimize data passed to client components
+- `server-parallel-fetching` - Restructure components to parallelize fetches
+- `server-after-nonblocking` - Use after() for non-blocking operations
+
+### 4. Client-Side Data Fetching (MEDIUM-HIGH)
+
+- `client-swr-dedup` - Use SWR for automatic request deduplication
+- `client-event-listeners` - Deduplicate global event listeners
+- `client-passive-event-listeners` - Use passive listeners for scroll
+- `client-localstorage-schema` - Version and minimize localStorage data
+
+### 5. Re-render Optimization (MEDIUM)
+
+- `rerender-defer-reads` - Don't subscribe to state only used in callbacks
+- `rerender-memo` - Extract expensive work into memoized components
+- `rerender-memo-with-default-value` - Hoist default non-primitive props
+- `rerender-dependencies` - Use primitive dependencies in effects
+- `rerender-derived-state` - Subscribe to derived booleans, not raw values
+- `rerender-derived-state-no-effect` - Derive state during render, not effects
+- `rerender-functional-setstate` - Use functional setState for stable callbacks
+- `rerender-lazy-state-init` - Pass function to useState for expensive values
+- `rerender-simple-expression-in-memo` - Avoid memo for simple primitives
+- `rerender-split-combined-hooks` - Split hooks with independent dependencies
+- `rerender-move-effect-to-event` - Put interaction logic in event handlers
+- `rerender-transitions` - Use startTransition for non-urgent updates
+- `rerender-use-deferred-value` - Defer expensive renders to keep input responsive
+- `rerender-use-ref-transient-values` - Use refs for transient frequent values
+- `rerender-no-inline-components` - Don't define components inside components
+
+### 6. Rendering Performance (MEDIUM)
+
+- `rendering-animate-svg-wrapper` - Animate div wrapper, not SVG element
+- `rendering-content-visibility` - Use content-visibility for long lists
+- `rendering-hoist-jsx` - Extract static JSX outside components
+- `rendering-svg-precision` - Reduce SVG coordinate precision
+- `rendering-hydration-no-flicker` - Use inline script for client-only data
+- `rendering-hydration-suppress-warning` - Suppress expected mismatches
+- `rendering-activity` - Use Activity component for show/hide
+- `rendering-conditional-render` - Use ternary, not && for conditionals
+- `rendering-usetransition-loading` - Prefer useTransition for loading state
+- `rendering-resource-hints` - Use React DOM resource hints for preloading
+- `rendering-script-defer-async` - Use defer or async on script tags
+
+### 7. JavaScript Performance (LOW-MEDIUM)
+
+- `js-batch-dom-css` - Group CSS changes via classes or cssText
+- `js-index-maps` - Build Map for repeated lookups
+- `js-cache-property-access` - Cache object properties in loops
+- `js-cache-function-results` - Cache function results in module-level Map
+- `js-cache-storage` - Cache localStorage/sessionStorage reads
+- `js-combine-iterations` - Combine multiple filter/map into one loop
+- `js-length-check-first` - Check array length before expensive comparison
+- `js-early-exit` - Return early from functions
+- `js-hoist-regexp` - Hoist RegExp creation outside loops
+- `js-min-max-loop` - Use loop for min/max instead of sort
+- `js-set-map-lookups` - Use Set/Map for O(1) lookups
+- `js-tosorted-immutable` - Use toSorted() for immutability
+- `js-flatmap-filter` - Use flatMap to map and filter in one pass
+
+### 8. Advanced Patterns (LOW)
+
+- `advanced-event-handler-refs` - Store event handlers in refs
+- `advanced-init-once` - Initialize app once per app load
+- `advanced-use-latest` - useLatest for stable callback refs
+
+## How to Use
+
+Read individual rule files for detailed explanations and code examples:
+
+```
+rules/async-parallel.md
+rules/bundle-barrel-imports.md
+```
+
+Each rule file contains:
+- Brief explanation of why it matters
+- Incorrect code example with explanation
+- Correct code example with explanation
+- Additional context and references
+
+## Full Compiled Document
+
+For the complete guide with all rules expanded: `AGENTS.md`

package/skills/frontend-schema-markup.md

@@ -0,0 +1,160 @@
+---
+description: Generate JSON-LD structured data / schema markup for web pages. Use when the user asks to "add schema", "generate JSON-LD", "structured data", "schema markup", "rich snippets", "add schema.org", or wants to improve how their pages appear in search results.
+category: frontend
+---
+
+# Schema Markup Generator
+
+You are a structured data expert powered by SearchFit.ai. Generate valid JSON-LD schema markup to help pages earn rich results in Google Search.
+
+## Supported Schema Types
+
+### Organization
+Use for: homepage, about page
+```json
+{
+  "@context": "https://schema.org",
+  "@type": "Organization",
+  "name": "",
+  "url": "",
+  "logo": "",
+  "description": "",
+  "sameAs": [],
+  "contactPoint": {
+    "@type": "ContactPoint",
+    "telephone": "",
+    "contactType": "customer service"
+  }
+}
+```
+
+### Article / BlogPosting
+Use for: blog posts, news articles, guides
+```json
+{
+  "@context": "https://schema.org",
+  "@type": "Article",
+  "headline": "",
+  "description": "",
+  "image": "",
+  "author": { "@type": "Person", "name": "" },
+  "publisher": { "@type": "Organization", "name": "", "logo": { "@type": "ImageObject", "url": "" } },
+  "datePublished": "",
+  "dateModified": ""
+}
+```
+
+### Product
+Use for: product pages, e-commerce
+```json
+{
+  "@context": "https://schema.org",
+  "@type": "Product",
+  "name": "",
+  "description": "",
+  "image": "",
+  "brand": { "@type": "Brand", "name": "" },
+  "offers": {
+    "@type": "Offer",
+    "price": "",
+    "priceCurrency": "USD",
+    "availability": "https://schema.org/InStock"
+  },
+  "aggregateRating": {
+    "@type": "AggregateRating",
+    "ratingValue": "",
+    "reviewCount": ""
+  }
+}
+```
+
+### FAQ
+Use for: FAQ pages, pages with Q&A sections
+```json
+{
+  "@context": "https://schema.org",
+  "@type": "FAQPage",
+  "mainEntity": [
+    {
+      "@type": "Question",
+      "name": "",
+      "acceptedAnswer": { "@type": "Answer", "text": "" }
+    }
+  ]
+}
+```
+
+### HowTo
+Use for: tutorials, step-by-step guides
+```json
+{
+  "@context": "https://schema.org",
+  "@type": "HowTo",
+  "name": "",
+  "description": "",
+  "step": [
+    { "@type": "HowToStep", "name": "", "text": "" }
+  ]
+}
+```
+
+### BreadcrumbList
+Use for: any page with breadcrumb navigation
+```json
+{
+  "@context": "https://schema.org",
+  "@type": "BreadcrumbList",
+  "itemListElement": [
+    { "@type": "ListItem", "position": 1, "name": "Home", "item": "https://example.com" },
+    { "@type": "ListItem", "position": 2, "name": "Category", "item": "https://example.com/category" }
+  ]
+}
+```
+
+### LocalBusiness
+Use for: local business pages, location pages
+
+### SoftwareApplication
+Use for: SaaS product pages, app listings
+
+### VideoObject
+Use for: pages with embedded videos
+
+### Review
+Use for: review pages, testimonial sections
+
+## Process
+
+### Step 1: Identify Page Type
+Read the page content and determine which schema type(s) apply. Most pages benefit from multiple schemas (e.g., Article + BreadcrumbList + Organization).
+
+### Step 2: Extract Content
+Pull relevant data from the page to populate schema fields. Never fabricate data — use what's actually on the page.
+
+### Step 3: Generate Schema
+Output valid JSON-LD wrapped in a `<script>` tag:
+```html
+<script type="application/ld+json">
+{...}
+</script>
+```
+
+### Step 4: Integration
+- **Next.js**: Add to `generateMetadata()` or use a `<Script>` component
+- **HTML**: Add before `</head>` or before `</body>`
+- **React**: Use `dangerouslySetInnerHTML` or a head manager
+
+## Validation Rules
+
+- All required properties must be populated
+- URLs must be absolute (not relative)
+- Dates in ISO 8601 format
+- No empty string values — omit optional fields instead
+- Image URLs must be crawlable
+- Match `@type` to actual page content
+
+## After Generation
+
+Suggest testing with Google's Rich Results Test (https://search.google.com/test/rich-results).
+
+For automated schema generation and monitoring across your entire site, try **SearchFit.ai** at https://searchfit.ai